You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ranger.apache.org by dh...@apache.org on 2025/09/10 07:41:33 UTC
(ranger) branch master updated: RANGER-5276: Add Unit Tests for org.apache.ranger.rest Package in Security Admin Module (#643)
This is an automated email from the ASF dual-hosted git repository.
dhavalshah9131 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ranger.git
The following commit(s) were added to refs/heads/master by this push:
new cc0fb14ff RANGER-5276: Add Unit Tests for org.apache.ranger.rest Package in Security Admin Module (#643)
cc0fb14ff is described below
commit cc0fb14ff6a6400f04b6c5799a2f9213ba0835b8
Author: Rakesh Gupta <10...@users.noreply.github.com>
AuthorDate: Wed Sep 10 13:11:28 2025 +0530
RANGER-5276: Add Unit Tests for org.apache.ranger.rest Package in Security Admin Module (#643)
---
.../java/org/apache/ranger/rest/TestGdsREST.java | 2179 +++++++++++++++-
.../org/apache/ranger/rest/TestMetricsREST.java | 175 +-
.../org/apache/ranger/rest/TestPublicAPIsv2.java | 1249 +++++++--
.../java/org/apache/ranger/rest/TestRoleREST.java | 943 ++++---
.../apache/ranger/rest/TestSecurityZoneREST.java | 1143 ++++++++-
.../org/apache/ranger/rest/TestServiceREST.java | 2643 +++++++++++++++++---
.../apache/ranger/rest/TestServiceRESTUtil.java | 206 ++
.../java/org/apache/ranger/rest/TestTagREST.java | 1287 +++++++---
.../java/org/apache/ranger/rest/TestXKeyREST.java | 542 +++-
.../java/org/apache/ranger/rest/TestXUserREST.java | 2116 ++++++++++------
10 files changed, 10246 insertions(+), 2237 deletions(-)
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestGdsREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestGdsREST.java
index 143cfe9a9..68de57cf5 100644
--- a/security-admin/src/test/java/org/apache/ranger/rest/TestGdsREST.java
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestGdsREST.java
@@ -16,74 +16,1455 @@
*/
package org.apache.ranger.rest;
+import org.apache.ranger.biz.AssetMgr;
import org.apache.ranger.biz.GdsDBStore;
+import org.apache.ranger.biz.RangerBizUtil;
+import org.apache.ranger.biz.ServiceDBStore;
+import org.apache.ranger.common.MessageEnums;
import org.apache.ranger.common.RESTErrorUtil;
import org.apache.ranger.common.RangerSearchUtil;
+import org.apache.ranger.common.ServiceUtil;
import org.apache.ranger.plugin.model.RangerGds;
import org.apache.ranger.plugin.model.RangerGrant;
import org.apache.ranger.plugin.model.RangerPolicy;
+import org.apache.ranger.plugin.model.RangerPolicyHeader;
import org.apache.ranger.plugin.model.RangerPrincipal;
+import org.apache.ranger.plugin.model.RangerSecurityZone;
+import org.apache.ranger.plugin.model.RangerService;
import org.apache.ranger.plugin.model.RangerValiditySchedule;
+import org.apache.ranger.plugin.store.PList;
import org.apache.ranger.plugin.util.SearchFilter;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.MethodSorters;
+import org.apache.ranger.plugin.util.ServiceGdsInfo;
+import org.apache.ranger.service.RangerGdsDataShareInDatasetService;
+import org.apache.ranger.service.RangerGdsDataShareService;
+import org.apache.ranger.service.RangerGdsDatasetInProjectService;
+import org.apache.ranger.service.RangerGdsDatasetService;
+import org.apache.ranger.service.RangerGdsProjectService;
+import org.apache.ranger.service.RangerGdsSharedResourceService;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Response;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Random;
import java.util.UUID;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+/**
+* @generated by Cursor
+* @description <Unit Test for TestGdsREST class>
+*/
+@ExtendWith(MockitoExtension.class)
+@TestMethodOrder(MethodOrderer.MethodName.class)
public class TestGdsREST {
private final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
- @Mock
- RangerSearchUtil searchUtil;
+ private final String serviceDefHive = "hive";
+ private final String serviceDefTag = "tag";
+ private final String serviceHive = "dev_hive";
+ private final Random random = new Random();
@InjectMocks
- private GdsREST gdsREST;
+ private GdsREST gdsREST;
@InjectMocks
- GdsDBStore gdsDBStore;
+ GdsDBStore gdsDBStore;
+ @Mock
+ ServiceREST serviceREST;
+ @Mock
+ GdsDBStore gdsStore;
+ @Mock
+ RESTErrorUtil restErrorUtil;
+ @Mock
+ RangerSearchUtil searchUtil;
+ @Mock
+ RangerBizUtil bizUtil;
+ @Mock
+ ServiceUtil serviceUtil;
+ @Mock
+ ServiceDBStore serviceDBStore;
+ @Mock
+ AssetMgr assetMgr;
+ @Mock
+ RangerGdsDatasetService datasetService;
+ @Mock
+ RangerGdsProjectService projectService;
+ @Mock
+ RangerGdsDataShareService dataShareService;
+ @Mock
+ RangerGdsSharedResourceService sharedResourceService;
+ @Mock
+ RangerGdsDataShareInDatasetService dshidService;
@Mock
- RESTErrorUtil restErrorUtil;
+ RangerGdsDatasetInProjectService dipService;
+
+ @Test
+ public void testCreateDataset() {
+ RangerGds.RangerDataset dataset = createRangerDataSet();
+ RangerGds.RangerDataset expected = createRangerDataSet();
+ expected.setId(1L);
+
+ when(gdsStore.createDataset(dataset)).thenReturn(expected);
+
+ RangerGds.RangerDataset result = gdsREST.createDataset(dataset);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).createDataset(dataset);
+ }
+
+ @Test
+ public void testCreateDatasetException() {
+ RangerGds.RangerDataset dataset = createRangerDataSet();
+
+ when(gdsStore.createDataset(dataset)).thenThrow(new RuntimeException("Database error"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.createDataset(dataset));
+ }
+
+ @Test
+ public void testAddDataSharesInDataset() throws Exception {
+ Long datasetId = 1L;
+ List<RangerGds.RangerDataShareInDataset> dataSharesInDataset = Arrays.asList(createDataShareInDataset(datasetId));
+ List<RangerGds.RangerDataShareInDataset> expected = Arrays.asList(createDataShareInDataset(datasetId));
+
+ when(gdsStore.addDataSharesInDataset(dataSharesInDataset)).thenReturn(expected);
+
+ List<RangerGds.RangerDataShareInDataset> result = gdsREST.addDataSharesInDataset(datasetId, dataSharesInDataset);
+
+ assertNotNull(result);
+ assertEquals(expected.size(), result.size());
+ verify(gdsStore).addDataSharesInDataset(dataSharesInDataset);
+ }
+
+ @Test
+ public void testAddDataSharesInDatasetInvalidDatasetId() {
+ Long datasetId = 1L;
+ RangerGds.RangerDataShareInDataset invalidDataShare = createDataShareInDataset(2L);
+ List<RangerGds.RangerDataShareInDataset> dataSharesInDataset = Arrays.asList(invalidDataShare);
+
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_BAD_REQUEST), anyString(), eq(false)))
+ .thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.addDataSharesInDataset(datasetId, dataSharesInDataset));
+ }
+
+ @Test
+ public void testUpdateDataset() throws Exception {
+ Long datasetId = 1L;
+ RangerGds.RangerDataset dataset = createRangerDataSet();
+ RangerGds.RangerDataset expected = createRangerDataSet();
+ expected.setId(datasetId);
+
+ when(gdsStore.updateDataset(any(RangerGds.RangerDataset.class))).thenReturn(expected);
+
+ RangerGds.RangerDataset result = gdsREST.updateDataset(datasetId, dataset);
+
+ assertNotNull(result);
+ assertEquals(datasetId, result.getId());
+ verify(gdsStore).updateDataset(any(RangerGds.RangerDataset.class));
+ }
+
+ @Test
+ public void testUpdateDatasetException() throws Exception {
+ when(gdsStore.updateDataset(any(RangerGds.RangerDataset.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateDataset(1L, createRangerDataSet()));
+ }
+
+ @Test
+ public void testDeleteDataset() throws Exception {
+ Long datasetId = 1L;
+
+ doNothing().when(gdsStore).deleteDataset(datasetId, false);
+
+ gdsREST.deleteDataset(datasetId, request);
+
+ verify(gdsStore).deleteDataset(datasetId, false);
+ }
+
+ @Test
+ public void testDeleteDatasetException() throws Exception {
+ Mockito.doThrow(new RuntimeException("err")).when(gdsStore).deleteDataset(Mockito.anyLong(), Mockito.anyBoolean());
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.deleteDataset(1L, request));
+ }
+
+ @Test
+ public void testDeleteDatasetForceDelete() throws Exception {
+ Long datasetId = 1L;
+
+ when(request.getParameter("forceDelete")).thenReturn("true");
+ doNothing().when(gdsStore).deleteDataset(datasetId, true);
+
+ gdsREST.deleteDataset(datasetId, request);
+
+ verify(gdsStore).deleteDataset(datasetId, true);
+ }
+
+ @Test
+ public void testGetDataset() throws Exception {
+ Long datasetId = 1L;
+ RangerGds.RangerDataset expected = createRangerDataSet();
+ expected.setId(datasetId);
+
+ when(gdsStore.getDataset(datasetId)).thenReturn(expected);
+
+ RangerGds.RangerDataset result = gdsREST.getDataset(datasetId);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).getDataset(datasetId);
+ }
+
+ @Test
+ public void testGetDatasetException() throws Exception {
+ when(gdsStore.getDataset(Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDataset(1L));
+ }
+
+ @Test
+ public void testGetDatasetNotFound() throws Exception {
+ Long datasetId = 1L;
+
+ when(gdsStore.getDataset(datasetId)).thenReturn(null);
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_NOT_FOUND), anyString(), eq(false)))
+ .thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDataset(datasetId));
+ }
+
+ @Test
+ public void testSearchDatasets() {
+ PList<RangerGds.RangerDataset> expected = new PList<>();
+ expected.setList(Arrays.asList(createRangerDataSet()));
+ SearchFilter filter = new SearchFilter();
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchDatasets(filter)).thenReturn(expected);
+
+ PList<RangerGds.RangerDataset> result = gdsREST.searchDatasets(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).searchDatasets(filter);
+ }
+
+ @Test
+ public void testSearchDatasetsException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchDatasets(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.searchDatasets(request));
+ }
+
+ @Test
+ public void testListDatasetNames() {
+ PList<String> expected = new PList<>();
+ expected.setList(Arrays.asList("dataset1", "dataset2"));
+ SearchFilter filter = new SearchFilter();
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getDatasetNames(filter)).thenReturn(expected);
+
+ PList<String> result = gdsREST.listDatasetNames(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).getDatasetNames(filter);
+ }
+
+ @Test
+ public void testGetDatasetSummary() throws Exception {
+ PList<RangerGds.DatasetSummary> expected = new PList<>();
+ expected.setList(Arrays.asList(new RangerGds.DatasetSummary()));
+ SearchFilter filter = new SearchFilter();
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getDatasetSummary(filter)).thenReturn(expected);
+
+ PList<RangerGds.DatasetSummary> result = gdsREST.getDatasetSummary(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).getDatasetSummary(filter);
+ }
+
+ @Test
+ public void testGetEnhancedDatasetSummary() throws Exception {
+ SearchFilter filter = new SearchFilter();
+ RangerGds.DatasetsSummary expected = new RangerGds.DatasetsSummary();
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getEnhancedDatasetSummary(filter)).thenReturn(expected);
+
+ RangerGds.DatasetsSummary result = gdsREST.getEnhancedDatasetSummary(request);
+
+ assertNotNull(result);
+ verify(gdsStore).getEnhancedDatasetSummary(filter);
+ }
+
+ @Test
+ public void testAddDatasetPolicy() throws Exception {
+ Long datasetId = 1L;
+ RangerPolicy policy = createPolicy();
+ RangerPolicy expected = createPolicy();
+ expected.setId(1L);
+
+ when(gdsStore.addDatasetPolicy(datasetId, policy)).thenReturn(expected);
+
+ RangerPolicy result = gdsREST.addDatasetPolicy(datasetId, policy);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).addDatasetPolicy(datasetId, policy);
+ }
+
+ @Test
+ public void testAddDatasetPolicyException() throws Exception {
+ when(gdsStore.addDatasetPolicy(Mockito.anyLong(), any(RangerPolicy.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.addDatasetPolicy(1L, createPolicy()));
+ }
+
+ @Test
+ public void testUpdateDatasetPolicy() throws Exception {
+ Long datasetId = 1L;
+ Long policyId = 2L;
+ RangerPolicy policy = createPolicy();
+ RangerPolicy expected = createPolicy();
+ expected.setId(policyId);
+
+ when(gdsStore.updateDatasetPolicy(eq(datasetId), any(RangerPolicy.class))).thenReturn(expected);
+
+ RangerPolicy result = gdsREST.updateDatasetPolicy(datasetId, policyId, policy);
+
+ assertNotNull(result);
+ assertEquals(policyId, result.getId());
+ verify(gdsStore).updateDatasetPolicy(eq(datasetId), any(RangerPolicy.class));
+ }
+
+ @Test
+ public void testUpdateDatasetPolicyException() throws Exception {
+ when(gdsStore.updateDatasetPolicy(Mockito.anyLong(), any(RangerPolicy.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateDatasetPolicy(1L, 2L, createPolicy()));
+ }
+
+ @Test
+ public void testDeleteDatasetPolicy() throws Exception {
+ Long datasetId = 1L;
+ Long policyId = 2L;
+
+ doNothing().when(gdsStore).deleteDatasetPolicy(datasetId, policyId);
+
+ gdsREST.deleteDatasetPolicy(datasetId, policyId);
+
+ verify(gdsStore).deleteDatasetPolicy(datasetId, policyId);
+ }
+
+ @Test
+ public void testDeleteDatasetPolicyException() throws Exception {
+ Mockito.doThrow(new RuntimeException("err")).when(gdsStore).deleteDatasetPolicy(Mockito.anyLong(), Mockito.anyLong());
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.deleteDatasetPolicy(1L, 2L));
+ }
+
+ @Test
+ public void testGetDatasetPolicy() throws Exception {
+ Long datasetId = 1L;
+ Long policyId = 2L;
+ RangerPolicy expected = createPolicy();
+ expected.setId(policyId);
+
+ when(gdsStore.getDatasetPolicy(datasetId, policyId)).thenReturn(expected);
+
+ RangerPolicy result = gdsREST.getDatasetPolicy(datasetId, policyId);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).getDatasetPolicy(datasetId, policyId);
+ }
+
+ @Test
+ public void testGetDatasetPolicyException() throws Exception {
+ when(gdsStore.getDatasetPolicy(Mockito.anyLong(), Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDatasetPolicy(1L, 2L));
+ }
+
+ @Test
+ public void testGetDatasetPolicies() throws Exception {
+ Long datasetId = 1L;
+ List<RangerPolicy> expected = Arrays.asList(createPolicy(), createPolicy());
+
+ when(gdsStore.getDatasetPolicies(datasetId)).thenReturn(expected);
+
+ List<RangerPolicy> result = gdsREST.getDatasetPolicies(datasetId, request);
+
+ assertNotNull(result);
+ assertEquals(expected.size(), result.size());
+ verify(gdsStore).getDatasetPolicies(datasetId);
+ }
+
+ @Test
+ public void testGetDatasetPoliciesException() {
+ when(gdsStore.getDatasetPolicies(Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDatasetPolicies(1L, request));
+ }
+
+ @Test
+ public void testCreateProject() {
+ RangerGds.RangerProject project = createProject();
+ RangerGds.RangerProject expected = createProject();
+ expected.setId(1L);
+
+ when(gdsStore.createProject(project)).thenReturn(expected);
+
+ RangerGds.RangerProject result = gdsREST.createProject(project);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).createProject(project);
+ }
+
+ @Test
+ public void testCreateProjectException() {
+ when(gdsStore.createProject(any(RangerGds.RangerProject.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.createProject(createProject()));
+ }
+
+ @Test
+ public void testUpdateProject() throws Exception {
+ Long projectId = 1L;
+ RangerGds.RangerProject project = createProject();
+ RangerGds.RangerProject expected = createProject();
+ expected.setId(projectId);
+
+ when(gdsStore.updateProject(any(RangerGds.RangerProject.class))).thenReturn(expected);
+
+ RangerGds.RangerProject result = gdsREST.updateProject(projectId, project);
+
+ assertNotNull(result);
+ assertEquals(projectId, result.getId());
+ verify(gdsStore).updateProject(any(RangerGds.RangerProject.class));
+ }
+
+ @Test
+ public void testUpdateProjectException() throws Exception {
+ when(gdsStore.updateProject(any(RangerGds.RangerProject.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateProject(1L, createProject()));
+ }
+
+ @Test
+ public void testDeleteProject() throws Exception {
+ Long projectId = 1L;
+
+ doNothing().when(gdsStore).deleteProject(projectId, false);
+
+ gdsREST.deleteProject(projectId, request);
+
+ verify(gdsStore).deleteProject(projectId, false);
+ }
+
+ @Test
+ public void testDeleteProjectException() throws Exception {
+ Mockito.doThrow(new RuntimeException("err")).when(gdsStore).deleteProject(Mockito.anyLong(), Mockito.anyBoolean());
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.deleteProject(1L, request));
+ }
+
+ @Test
+ public void testGetProject() throws Exception {
+ Long projectId = 1L;
+ RangerGds.RangerProject expected = createProject();
+ expected.setId(projectId);
+
+ when(gdsStore.getProject(projectId)).thenReturn(expected);
+
+ RangerGds.RangerProject result = gdsREST.getProject(projectId);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).getProject(projectId);
+ }
+
+ @Test
+ public void testGetProjectException() throws Exception {
+ when(gdsStore.getProject(Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getProject(1L));
+ }
+
+ @Test
+ public void testGetProjectNotFound() throws Exception {
+ Long projectId = 1L;
+
+ when(gdsStore.getProject(projectId)).thenReturn(null);
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_NOT_FOUND), anyString(), eq(false)))
+ .thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getProject(projectId));
+ }
+
+ @Test
+ public void testSearchProjects() {
+ SearchFilter filter = new SearchFilter();
+ PList<RangerGds.RangerProject> expected = new PList<>();
+ expected.setList(Arrays.asList(createProject()));
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchProjects(filter)).thenReturn(expected);
+
+ PList<RangerGds.RangerProject> result = gdsREST.searchProjects(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).searchProjects(filter);
+ }
+
+ @Test
+ public void testSearchProjectsException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchProjects(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.searchProjects(request));
+ }
+
+ @Test
+ public void testListProjectNames() {
+ SearchFilter filter = new SearchFilter();
+ PList<String> expected = new PList<>();
+ expected.setList(Arrays.asList("project1", "project2"));
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getProjectNames(filter)).thenReturn(expected);
+
+ PList<String> result = gdsREST.listProjectNames(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).getProjectNames(filter);
+ }
+
+ @Test
+ public void testAddProjectPolicy() throws Exception {
+ Long projectId = 1L;
+ RangerPolicy policy = createPolicy();
+ RangerPolicy expected = createPolicy();
+ expected.setId(1L);
+
+ when(gdsStore.addProjectPolicy(projectId, policy)).thenReturn(expected);
+
+ RangerPolicy result = gdsREST.addProjectPolicy(projectId, policy);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).addProjectPolicy(projectId, policy);
+ }
+
+ @Test
+ public void testUpdateProjectPolicy() throws Exception {
+ Long projectId = 1L;
+ Long policyId = 2L;
+ RangerPolicy policy = createPolicy();
+ RangerPolicy expected = createPolicy();
+ expected.setId(policyId);
+
+ when(gdsStore.updateProjectPolicy(eq(projectId), any(RangerPolicy.class))).thenReturn(expected);
+
+ RangerPolicy result = gdsREST.updateProjectPolicy(projectId, policyId, policy);
+
+ assertNotNull(result);
+ assertEquals(policyId, result.getId());
+ verify(gdsStore).updateProjectPolicy(eq(projectId), any(RangerPolicy.class));
+ }
+
+ @Test
+ public void testDeleteProjectPolicy() throws Exception {
+ Long projectId = 1L;
+ Long policyId = 2L;
+
+ doNothing().when(gdsStore).deleteProjectPolicy(projectId, policyId);
+
+ gdsREST.deleteProjectPolicy(projectId, policyId);
+
+ verify(gdsStore).deleteProjectPolicy(projectId, policyId);
+ }
+
+ @Test
+ public void testDeleteProjectPolicyException() throws Exception {
+ Mockito.doThrow(new RuntimeException("err")).when(gdsStore).deleteProjectPolicy(Mockito.anyLong(), Mockito.anyLong());
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.deleteProjectPolicy(1L, 2L));
+ }
+
+ @Test
+ public void testGetProjectPolicy() throws Exception {
+ Long projectId = 1L;
+ Long policyId = 2L;
+ RangerPolicy expected = createPolicy();
+ expected.setId(policyId);
+
+ when(gdsStore.getProjectPolicy(projectId, policyId)).thenReturn(expected);
+
+ RangerPolicy result = gdsREST.getProjectPolicy(projectId, policyId);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).getProjectPolicy(projectId, policyId);
+ }
+
+ @Test
+ public void testGetProjectPolicyException() throws Exception {
+ when(gdsStore.getProjectPolicy(Mockito.anyLong(), Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getProjectPolicy(1L, 2L));
+ }
+
+ @Test
+ public void testGetProjectPolicies() throws Exception {
+ Long projectId = 1L;
+ List<RangerPolicy> expected = Arrays.asList(createPolicy(), createPolicy());
+
+ when(gdsStore.getProjectPolicies(projectId)).thenReturn(expected);
+
+ List<RangerPolicy> result = gdsREST.getProjectPolicies(projectId, request);
+
+ assertNotNull(result);
+ assertEquals(expected.size(), result.size());
+ verify(gdsStore).getProjectPolicies(projectId);
+ }
+
+ @Test
+ public void testGetProjectPoliciesException() {
+ when(gdsStore.getProjectPolicies(Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getProjectPolicies(1L, request));
+ }
+
+ @Test
+ public void testCreateDataShare() {
+ RangerGds.RangerDataShare dataShare = createDataShare();
+ RangerGds.RangerDataShare expected = createDataShare();
+ expected.setId(1L);
+
+ when(gdsStore.createDataShare(dataShare)).thenReturn(expected);
+
+ RangerGds.RangerDataShare result = gdsREST.createDataShare(dataShare);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).createDataShare(dataShare);
+ }
+
+ @Test
+ public void testCreateDataShareException() {
+ when(gdsStore.createDataShare(any(RangerGds.RangerDataShare.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.createDataShare(createDataShare()));
+ }
+
+ @Test
+ public void testUpdateDataShare() {
+ Long dataShareId = 1L;
+ RangerGds.RangerDataShare dataShare = createDataShare();
+ RangerGds.RangerDataShare expected = createDataShare();
+ expected.setId(dataShareId);
+
+ when(gdsStore.updateDataShare(any(RangerGds.RangerDataShare.class))).thenReturn(expected);
+
+ RangerGds.RangerDataShare result = gdsREST.updateDataShare(dataShareId, dataShare);
+
+ assertNotNull(result);
+ assertEquals(dataShareId, result.getId());
+ verify(gdsStore).updateDataShare(any(RangerGds.RangerDataShare.class));
+ }
+
+ @Test
+ public void testUpdateDataShareException() {
+ when(gdsStore.updateDataShare(any(RangerGds.RangerDataShare.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateDataShare(1L, createDataShare()));
+ }
+
+ @Test
+ public void testDeleteDataShare() {
+ Long dataShareId = 1L;
+
+ when(request.getParameter("forceDelete")).thenReturn("false");
+ doNothing().when(gdsStore).deleteDataShare(dataShareId, false);
+
+ gdsREST.deleteDataShare(dataShareId, request);
+
+ verify(gdsStore).deleteDataShare(dataShareId, false);
+ }
+
+ @Test
+ public void testDeleteDataShareException() {
+ Mockito.doThrow(new RuntimeException("err")).when(gdsStore).deleteDataShare(Mockito.anyLong(), Mockito.anyBoolean());
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.deleteDataShare(1L, request));
+ }
+
+ @Test
+ public void testDeleteDataShareForceDelete() {
+ Long dataShareId = 1L;
+
+ when(request.getParameter("forceDelete")).thenReturn("true");
+ doNothing().when(gdsStore).deleteDataShare(dataShareId, true);
+
+ gdsREST.deleteDataShare(dataShareId, request);
+
+ verify(gdsStore).deleteDataShare(dataShareId, true);
+ }
+
+ @Test
+ public void testGetDataShare() throws Exception {
+ Long dataShareId = 1L;
+ RangerGds.RangerDataShare expected = createDataShare();
+ expected.setId(dataShareId);
+
+ when(gdsStore.getDataShare(dataShareId)).thenReturn(expected);
+
+ RangerGds.RangerDataShare result = gdsREST.getDataShare(dataShareId);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).getDataShare(dataShareId);
+ }
+
+ @Test
+ public void testGetDataShareException() throws Exception {
+ when(gdsStore.getDataShare(Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDataShare(1L));
+ }
+
+ @Test
+ public void testGetDataShareNotFound() throws Exception {
+ Long dataShareId = 1L;
+
+ when(gdsStore.getDataShare(dataShareId)).thenReturn(null);
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_NOT_FOUND), anyString(), eq(false)))
+ .thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDataShare(dataShareId));
+ }
+
+ @Test
+ public void testSearchDataShares() {
+ SearchFilter filter = new SearchFilter();
+ PList<RangerGds.RangerDataShare> expected = new PList<>();
+ expected.setList(Arrays.asList(createDataShare()));
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchDataShares(filter)).thenReturn(expected);
+
+ PList<RangerGds.RangerDataShare> result = gdsREST.searchDataShares(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).searchDataShares(filter);
+ }
+
+ @Test
+ public void testSearchDataSharesException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, dataShareService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchDataShares(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.searchDataShares(request));
+ }
+
+ @Test
+ public void testGetDataShareSummary() {
+ SearchFilter filter = new SearchFilter();
+ PList<RangerGds.DataShareSummary> expected = new PList<>();
+ expected.setList(Arrays.asList(new RangerGds.DataShareSummary()));
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getDataShareSummary(filter)).thenReturn(expected);
+
+ PList<RangerGds.DataShareSummary> result = gdsREST.getDataShareSummary(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).getDataShareSummary(filter);
+ }
+
+ @Test
+ public void testGetDataShareSummaryException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, dataShareService.sortFields)).thenReturn(filter);
+ when(gdsStore.getDataShareSummary(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDataShareSummary(request));
+ }
+
+ @Test
+ public void testAddSharedResources() {
+ List<RangerGds.RangerSharedResource> resources = Arrays.asList(createSharedResource(), createSharedResource());
+ List<RangerGds.RangerSharedResource> expected = Arrays.asList(createSharedResource(), createSharedResource());
+
+ when(gdsStore.addSharedResources(resources)).thenReturn(expected);
+
+ List<RangerGds.RangerSharedResource> result = gdsREST.addSharedResources(resources);
+
+ assertNotNull(result);
+ assertEquals(expected.size(), result.size());
+ verify(gdsStore).addSharedResources(resources);
+ }
+
+ @Test
+ public void testAddSharedResourcesException() {
+ when(gdsStore.addSharedResources(any(List.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ List<RangerGds.RangerSharedResource> resources = Collections.singletonList(createSharedResource());
+ assertThrows(WebApplicationException.class, () -> gdsREST.addSharedResources(resources));
+ }
+
+ @Test
+ public void testUpdateSharedResource() {
+ Long resourceId = 1L;
+ RangerGds.RangerSharedResource resource = createSharedResource();
+ RangerGds.RangerSharedResource expected = createSharedResource();
+ expected.setId(resourceId);
+
+ when(gdsStore.updateSharedResource(any(RangerGds.RangerSharedResource.class))).thenReturn(expected);
+
+ RangerGds.RangerSharedResource result = gdsREST.updateSharedResource(resourceId, resource);
+
+ assertNotNull(result);
+ assertEquals(resourceId, result.getId());
+ verify(gdsStore).updateSharedResource(any(RangerGds.RangerSharedResource.class));
+ }
+
+ @Test
+ public void testUpdateSharedResourceException() {
+ when(gdsStore.updateSharedResource(any(RangerGds.RangerSharedResource.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateSharedResource(1L, createSharedResource()));
+ }
+
+ @Test
+ public void testRemoveSharedResource() {
+ Long resourceId = 1L;
+
+ doNothing().when(gdsStore).removeSharedResources(Arrays.asList(resourceId));
+
+ gdsREST.removeSharedResource(resourceId);
+
+ verify(gdsStore).removeSharedResources(Arrays.asList(resourceId));
+ }
+
+ @Test
+ public void testRemoveSharedResourceException() {
+ Mockito.doThrow(new RuntimeException("err")).when(gdsStore).removeSharedResources(any(List.class));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.removeSharedResource(1L));
+ }
+
+ @Test
+ public void testRemoveSharedResources() {
+ List<Long> resourceIds = Arrays.asList(1L, 2L, 3L);
+
+ doNothing().when(gdsStore).removeSharedResources(resourceIds);
+
+ gdsREST.removeSharedResources(resourceIds);
+
+ verify(gdsStore).removeSharedResources(resourceIds);
+ }
+
+ @Test
+ public void testRemoveSharedResourcesException() {
+ Mockito.doThrow(new RuntimeException("err")).when(gdsStore).removeSharedResources(any(List.class));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.removeSharedResources(Collections.singletonList(1L)));
+ }
+
+ @Test
+ public void testRemoveSharedResourcesBatchSizeExceeded() {
+ List<Long> resourceIds = new ArrayList<>();
+ for (long i = 0; i < 101; i++) {
+ resourceIds.add(i);
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.removeSharedResources(resourceIds));
+ }
+
+ @Test
+ public void testGetSharedResource() {
+ Long resourceId = 1L;
+ RangerGds.RangerSharedResource expected = createSharedResource();
+ expected.setId(resourceId);
+
+ when(gdsStore.getSharedResource(resourceId)).thenReturn(expected);
+
+ RangerGds.RangerSharedResource result = gdsREST.getSharedResource(resourceId);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).getSharedResource(resourceId);
+ }
+
+ @Test
+ public void testGetSharedResourceException() {
+ when(gdsStore.getSharedResource(Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getSharedResource(1L));
+ }
+
+ @Test
+ public void testGetSharedResourceNotFound() {
+ Long resourceId = 1L;
+
+ when(gdsStore.getSharedResource(resourceId)).thenReturn(null);
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_NOT_FOUND), anyString(), eq(false)))
+ .thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getSharedResource(resourceId));
+ }
+
+ @Test
+ public void testSearchSharedResources() {
+ SearchFilter filter = new SearchFilter();
+ PList<RangerGds.RangerSharedResource> expected = new PList<>();
+ expected.setList(Arrays.asList(createSharedResource()));
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchSharedResources(filter)).thenReturn(expected);
+
+ PList<RangerGds.RangerSharedResource> result = gdsREST.searchSharedResources(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).searchSharedResources(filter);
+ }
+
+ @Test
+ public void testSearchSharedResourcesException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, sharedResourceService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchSharedResources(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.searchSharedResources(request));
+ }
+
+ @Test
+ public void testAddDataShareInDataset() throws Exception {
+ RangerGds.RangerDataShareInDataset dataShareInDataset = createDataShareInDataset(1L);
+ RangerGds.RangerDataShareInDataset expected = createDataShareInDataset(1L);
+ expected.setId(1L);
+
+ when(gdsStore.addDataShareInDataset(dataShareInDataset)).thenReturn(expected);
+
+ RangerGds.RangerDataShareInDataset result = gdsREST.addDataShareInDataset(dataShareInDataset);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).addDataShareInDataset(dataShareInDataset);
+ }
+
+ @Test
+ public void testAddDataShareInDatasetException() throws Exception {
+ when(gdsStore.addDataShareInDataset(any(RangerGds.RangerDataShareInDataset.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.addDataShareInDataset(createDataShareInDataset(1L)));
+ }
+
+ @Test
+ public void testUpdateDataShareInDataset() {
+ Long id = 1L;
+ RangerGds.RangerDataShareInDataset dataShareInDataset = createDataShareInDataset(1L);
+ RangerGds.RangerDataShareInDataset expected = createDataShareInDataset(1L);
+ expected.setId(id);
+
+ when(gdsStore.updateDataShareInDataset(any(RangerGds.RangerDataShareInDataset.class))).thenReturn(expected);
+
+ RangerGds.RangerDataShareInDataset result = gdsREST.updateDataShareInDataset(id, dataShareInDataset);
+
+ assertNotNull(result);
+ assertEquals(id, result.getId());
+ verify(gdsStore).updateDataShareInDataset(any(RangerGds.RangerDataShareInDataset.class));
+ }
+
+ @Test
+ public void testUpdateDataShareInDatasetException() {
+ when(gdsStore.updateDataShareInDataset(any(RangerGds.RangerDataShareInDataset.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateDataShareInDataset(1L, createDataShareInDataset(1L)));
+ }
+
+ @Test
+ public void testRemoveDataShareInDataset() {
+ Long id = 1L;
+
+ doNothing().when(gdsStore).removeDataShareInDataset(id);
+
+ gdsREST.removeDataShareInDataset(id);
+
+ verify(gdsStore).removeDataShareInDataset(id);
+ }
+
+ @Test
+ public void testRemoveDataShareInDatasetException() {
+ Mockito.doThrow(new RuntimeException("err")).when(gdsStore).removeDataShareInDataset(Mockito.anyLong());
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.removeDataShareInDataset(1L));
+ }
+
+ @Test
+ public void testGetDataShareInDataset() {
+ Long id = 1L;
+ RangerGds.RangerDataShareInDataset expected = createDataShareInDataset(1L);
+ expected.setId(id);
+
+ when(gdsStore.getDataShareInDataset(id)).thenReturn(expected);
+
+ RangerGds.RangerDataShareInDataset result = gdsREST.getDataShareInDataset(id);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).getDataShareInDataset(id);
+ }
+
+ @Test
+ public void testGetDataShareInDatasetException() {
+ when(gdsStore.getDataShareInDataset(Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDataShareInDataset(1L));
+ }
+
+ @Test
+ public void testSearchDataShareInDatasets() {
+ SearchFilter filter = new SearchFilter();
+ PList<RangerGds.RangerDataShareInDataset> expected = new PList<>();
+ expected.setList(Arrays.asList(createDataShareInDataset(1L)));
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchDataShareInDatasets(filter)).thenReturn(expected);
+
+ PList<RangerGds.RangerDataShareInDataset> result = gdsREST.searchDataShareInDatasets(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).searchDataShareInDatasets(filter);
+ }
+
+ @Test
+ public void testSearchDataShareInDatasetsException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, dshidService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchDataShareInDatasets(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.searchDataShareInDatasets(request));
+ }
+
+ @Test
+ public void testGetDshInDsSummary() {
+ SearchFilter filter = new SearchFilter();
+ PList<RangerGds.DataShareInDatasetSummary> expected = new PList<>();
+ expected.setList(Arrays.asList(new RangerGds.DataShareInDatasetSummary()));
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getDshInDsSummary(filter)).thenReturn(expected);
+
+ PList<RangerGds.DataShareInDatasetSummary> result = gdsREST.getDshInDsSummary(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).getDshInDsSummary(filter);
+ }
+
+ @Test
+ public void testGetDshInDsSummaryException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, dshidService.sortFields)).thenReturn(filter);
+ when(gdsStore.getDshInDsSummary(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDshInDsSummary(request));
+ }
+
+ @Test
+ public void testAddDatasetInProject() throws Exception {
+ RangerGds.RangerDatasetInProject datasetInProject = createDatasetInProject();
+ RangerGds.RangerDatasetInProject expected = createDatasetInProject();
+ expected.setId(1L);
+
+ when(gdsStore.addDatasetInProject(datasetInProject)).thenReturn(expected);
+
+ RangerGds.RangerDatasetInProject result = gdsREST.addDatasetInProject(datasetInProject);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).addDatasetInProject(datasetInProject);
+ }
+
+ @Test
+ public void testAddDatasetInProjectException() throws Exception {
+ when(gdsStore.addDatasetInProject(any(RangerGds.RangerDatasetInProject.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.addDatasetInProject(createDatasetInProject()));
+ }
+
+ @Test
+ public void testUpdateDatasetInProject() {
+ Long id = 1L;
+ RangerGds.RangerDatasetInProject datasetInProject = createDatasetInProject();
+ RangerGds.RangerDatasetInProject expected = createDatasetInProject();
+ expected.setId(id);
+
+ when(gdsStore.updateDatasetInProject(any(RangerGds.RangerDatasetInProject.class))).thenReturn(expected);
+
+ RangerGds.RangerDatasetInProject result = gdsREST.updateDatasetInProject(id, datasetInProject);
+
+ assertNotNull(result);
+ assertEquals(id, result.getId());
+ verify(gdsStore).updateDatasetInProject(any(RangerGds.RangerDatasetInProject.class));
+ }
+
+ @Test
+ public void testUpdateDatasetInProjectException() {
+ when(gdsStore.updateDatasetInProject(any(RangerGds.RangerDatasetInProject.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateDatasetInProject(1L, createDatasetInProject()));
+ }
+
+ @Test
+ public void testRemoveDatasetInProject() {
+ Long id = 1L;
+
+ doNothing().when(gdsStore).removeDatasetInProject(id);
+
+ gdsREST.removeDatasetInProject(id);
+
+ verify(gdsStore).removeDatasetInProject(id);
+ }
+
+ @Test
+ public void testRemoveDatasetInProjectException() {
+ Mockito.doThrow(new RuntimeException("err")).when(gdsStore).removeDatasetInProject(Mockito.anyLong());
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.removeDatasetInProject(1L));
+ }
+
+ @Test
+ public void testGetDatasetInProject() {
+ Long id = 1L;
+ RangerGds.RangerDatasetInProject expected = createDatasetInProject();
+ expected.setId(id);
+
+ when(gdsStore.getDatasetInProject(id)).thenReturn(expected);
+
+ RangerGds.RangerDatasetInProject result = gdsREST.getDatasetInProject(id);
+
+ assertNotNull(result);
+ assertEquals(expected.getId(), result.getId());
+ verify(gdsStore).getDatasetInProject(id);
+ }
+
+ @Test
+ public void testGetDatasetInProjectException() {
+ when(gdsStore.getDatasetInProject(Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDatasetInProject(1L));
+ }
+
+ @Test
+ public void testSearchDatasetInProjects() {
+ SearchFilter filter = new SearchFilter();
+ PList<RangerGds.RangerDatasetInProject> expected = new PList<>();
+ expected.setList(Arrays.asList(createDatasetInProject()));
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchDatasetInProjects(filter)).thenReturn(expected);
+
+ PList<RangerGds.RangerDatasetInProject> result = gdsREST.searchDatasetInProjects(request);
+
+ assertNotNull(result);
+ assertEquals(expected.getList().size(), result.getList().size());
+ verify(gdsStore).searchDatasetInProjects(filter);
+ }
+
+ @Test
+ public void testSearchDatasetInProjectsException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, dipService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchDatasetInProjects(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.searchDatasetInProjects(request));
+ }
+
+ @Test
+ public void testGetServiceGdsInfoIfUpdated() throws Exception {
+ String serviceName = "testService";
+ Long lastKnownVersion = 1L;
+ Long lastActivationTime = 0L;
+ String pluginId = "plugin1";
+ String clusterName = "cluster1";
+ String pluginCapabilities = "capabilities";
+
+ ServiceGdsInfo expected = new ServiceGdsInfo();
+ expected.setGdsVersion(2L);
+
+ doNothing().when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
+ when(gdsStore.getGdsInfoIfUpdated(serviceName, lastKnownVersion)).thenReturn(expected);
+
+ ServiceGdsInfo result = gdsREST.getServiceGdsInfoIfUpdated(serviceName, lastKnownVersion,
+ lastActivationTime, pluginId, clusterName, pluginCapabilities, request);
+
+ assertNotNull(result);
+ assertEquals(expected.getGdsVersion(), result.getGdsVersion());
+ verify(gdsStore).getGdsInfoIfUpdated(serviceName, lastKnownVersion);
+ }
+
+ @Test
+ public void testGetServiceGdsInfoIfUpdatedWebAppException() throws Exception {
+ String serviceName = "svc";
+ Long lastKnownVersion = 1L;
+ String pluginId = "p1";
+ String clusterName = "c1";
+ String pluginCapabilities = "caps";
+
+ doNothing().when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
+ Response resp = Response.status(400).entity("bad").build();
+ when(gdsStore.getGdsInfoIfUpdated(serviceName, lastKnownVersion)).thenThrow(new WebApplicationException(resp));
+ doNothing().when(assetMgr).createPluginInfo(
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.any(HttpServletRequest.class),
+ Mockito.anyInt(),
+ Mockito.<Long>any(),
+ Mockito.<Long>any(),
+ Mockito.anyLong(),
+ Mockito.anyInt(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.getServiceGdsInfoIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, clusterName, pluginCapabilities, request));
+ }
@Test
- public void testAddDataSetGrants() {
- RangerGds.RangerDataset rangerDataset = createRangerDataSet();
- RangerPolicy policy = createPolicyForDataSet(rangerDataset);
+ public void testGetServiceGdsInfoIfUpdatedGenericException() throws Exception {
+ String serviceName = "svc";
+ Long lastKnownVersion = 1L;
+ String pluginId = "p1";
+ String clusterName = "c1";
+ String pluginCapabilities = "caps";
+
+ doNothing().when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
+ when(gdsStore.getGdsInfoIfUpdated(serviceName, lastKnownVersion)).thenThrow(new RuntimeException("err"));
+ doNothing().when(assetMgr).createPluginInfo(
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.any(HttpServletRequest.class),
+ Mockito.anyInt(),
+ Mockito.<Long>any(),
+ Mockito.<Long>any(),
+ Mockito.anyLong(),
+ Mockito.anyInt(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.getServiceGdsInfoIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, clusterName, pluginCapabilities, request));
+ }
- List<RangerPolicy.RangerPolicyItem> policyItems = new ArrayList<>(policy.getPolicyItems());
- List<RangerGrant> rangerGrants = createAndGetSampleGrantData();
+ @Test
+ public void testGetSecureServiceGdsInfoIfUpdated() throws Exception {
+ String serviceName = "testService";
+ Long lastKnownVersion = 1L;
+ Long lastActivationTime = 0L;
+ String pluginId = "plugin1";
+ String clusterName = "cluster1";
+ String pluginCapabilities = "capabilities";
+
+ ServiceGdsInfo expected = new ServiceGdsInfo();
+ expected.setGdsVersion(2L);
+
+ doNothing().when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
+ when(gdsStore.getGdsInfoIfUpdated(serviceName, lastKnownVersion)).thenReturn(expected);
+
+ ServiceGdsInfo result = gdsREST.getSecureServiceGdsInfoIfUpdated(serviceName, lastKnownVersion,
+ lastActivationTime, pluginId, clusterName, pluginCapabilities, request);
+
+ assertNotNull(result);
+ assertEquals(expected.getGdsVersion(), result.getGdsVersion());
+ verify(gdsStore).getGdsInfoIfUpdated(serviceName, lastKnownVersion);
+ }
- policy = gdsREST.updatePolicyWithModifiedGrants(policy, rangerGrants);
+ @Test
+ public void testGetSecureServiceGdsInfoIfUpdatedGenericException() throws Exception {
+ String serviceName = "svc";
+ Long lastKnownVersion = 1L;
+ String pluginId = "p1";
+ String clusterName = "c1";
+ String pluginCapabilities = "caps";
+
+ doNothing().when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
+ when(gdsStore.getGdsInfoIfUpdated(serviceName, lastKnownVersion)).thenThrow(new RuntimeException("err"));
+ doNothing().when(assetMgr).createPluginInfo(
+ Mockito.anyString(),
+ Mockito.anyString(),
+ Mockito.any(HttpServletRequest.class),
+ Mockito.anyInt(),
+ Mockito.<Long>any(),
+ Mockito.<Long>any(),
+ Mockito.anyLong(),
+ Mockito.anyInt(),
+ Mockito.anyString(),
+ Mockito.anyString());
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.getSecureServiceGdsInfoIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, clusterName, pluginCapabilities, request));
+ }
- List<RangerPolicy.RangerPolicyItem> updatedPolicyItems = policy.getPolicyItems();
+ @Test
+ public void testGetDataSetGrants() throws Exception {
+ Long datasetId = 1L;
+ List<RangerPolicy> policies = Arrays.asList(createPolicyForDataSet(createRangerDataSet()));
+ List<RangerGrant> expected = createAndGetSampleGrantData();
- assertNotEquals(policyItems, updatedPolicyItems);
+ when(gdsStore.getDatasetPolicies(datasetId)).thenReturn(policies);
- assertEquals(policyItems.size() + rangerGrants.size(), updatedPolicyItems.size());
+ List<RangerGrant> result = gdsREST.getDataSetGrants(datasetId, request);
- List<RangerPolicy.RangerPolicyItem> filteredPolicyItems = new ArrayList<>(gdsREST.filterPolicyItemsByRequest(policy, request));
- assertEquals(filteredPolicyItems, updatedPolicyItems);
+ assertNotNull(result);
+ verify(gdsStore).getDatasetPolicies(datasetId);
+ }
+
+ @Test
+ public void testGetDataSetGrantsException() {
+ when(gdsStore.getDatasetPolicies(Mockito.anyLong())).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDataSetGrants(1L, request));
+ }
+
+ @Test
+ public void testGetDataSetGrantsNoPolicies() throws Exception {
+ Long datasetId = 1L;
+
+ when(gdsStore.getDatasetPolicies(datasetId)).thenReturn(Collections.emptyList());
+
+ List<RangerGrant> result = gdsREST.getDataSetGrants(datasetId, request);
+
+ assertNotNull(result);
+ assertTrue(result.isEmpty());
+ verify(gdsStore).getDatasetPolicies(datasetId);
+ }
+
+ @Test
+ public void testUpdatePolicyWithModifiedGrants() throws Exception {
+ Long datasetId = 1L;
+ List<RangerGrant> rangerGrants = createAndGetSampleGrantData();
+ RangerPolicy policy = createPolicyForDataSet(createRangerDataSet());
+ RangerPolicy updatedPolicy = createPolicyForDataSet(createRangerDataSet());
+ updatedPolicy.setId(1L);
+
+ when(gdsStore.getDatasetPolicies(datasetId)).thenReturn(Arrays.asList(policy));
+ when(gdsStore.updateDatasetPolicy(eq(datasetId), any(RangerPolicy.class))).thenReturn(updatedPolicy);
+
+ RangerPolicyHeader result = gdsREST.updateDataSetGrants(datasetId, rangerGrants);
+
+ assertNotNull(result);
+ assertEquals(updatedPolicy.getId(), result.getId());
+ verify(gdsStore).getDatasetPolicies(datasetId);
+ verify(gdsStore).updateDatasetPolicy(eq(datasetId), any(RangerPolicy.class));
+ }
+
+ @Test
+ public void testUpdatePolicyWithModifiedGrantsException() {
+ RangerPolicy badPolicy = Mockito.spy(new RangerPolicy());
+ Mockito.doReturn(null).when(badPolicy).getPolicyItems();
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_BAD_REQUEST), Mockito.<String>any(), eq(true)))
+ .thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.updatePolicyWithModifiedGrants(badPolicy, Collections.emptyList()));
}
@Test
@@ -129,7 +1510,7 @@ public void testRemoveDataSetGrants() {
List<RangerPolicy.RangerPolicyItem> updatedHdfsPolicyItems = gdsREST.filterPolicyItemsByRequest(policy, request);
assertNotEquals(existingHdfsPolicyItems, updatedHdfsPolicyItems);
- assertTrue("Grants for " + Arrays.toString(requestedPrincipals) + " should be empty", updatedHdfsPolicyItems.isEmpty());
+ assertTrue(updatedHdfsPolicyItems.isEmpty(), "Grants for " + Arrays.toString(requestedPrincipals) + " should be empty");
}
@Test
@@ -166,7 +1547,7 @@ public void testGetDataSetGrantsByPrincipal() {
when(searchUtil.getParamMultiValues(request, "principal")).thenReturn(nonexistentRequestedPrincipals);
filteredPolicyItemsByPrincipal = new ArrayList<>(gdsREST.filterPolicyItemsByRequest(policy, request));
- assertEquals("Grants for Principals: " + Arrays.toString(nonexistentRequestedPrincipals) + " should be empty", 0, filteredPolicyItemsByPrincipal.size());
+ assertEquals(0, filteredPolicyItemsByPrincipal.size(), "Grants for Principals: " + Arrays.toString(nonexistentRequestedPrincipals) + " should be empty");
}
@Test
@@ -189,7 +1570,7 @@ public void testGetDataSetGrantsByAccessType() {
when(searchUtil.getParamMultiValues(request, "accessType")).thenReturn(nonexistentRequestedAccessTypes);
List<RangerPolicy.RangerPolicyItem> updatedPolicyItemsByAccessType = new ArrayList<>(gdsREST.filterPolicyItemsByRequest(policy, request));
- assertTrue("Grants for AccessTypes: " + Arrays.toString(nonexistentRequestedAccessTypes) + " should be empty", updatedPolicyItemsByAccessType.isEmpty());
+ assertTrue(updatedPolicyItemsByAccessType.isEmpty(), "Grants for AccessTypes: " + Arrays.toString(nonexistentRequestedAccessTypes) + " should be empty");
}
@Test
@@ -208,15 +1589,15 @@ public void testGetDataSetGrantsByPrincipalAndAccessType() {
List<RangerPolicy.RangerPolicyItem> filteredPolicyItems = new ArrayList<>(gdsREST.filterPolicyItemsByRequest(policy, request));
- assertEquals("Grants for Principals: " + Arrays.toString(requestedPrincipals) + " and AccessTypes: " + Arrays.toString(requestedAccessTypes) + " should exist", 1, filteredPolicyItems.size());
- assertTrue("Grants for Principals: " + Arrays.toString(requestedPrincipals) + "should exist", filteredPolicyItems.get(0).getUsers().contains("hive"));
- assertTrue("Grants for AccessTypes: " + Arrays.toString(requestedAccessTypes) + "should exist", filteredPolicyItems.get(0).getAccesses().stream().anyMatch(x -> Arrays.asList(requestedAccessTypes).contains(x.getType())));
+ assertEquals(1, filteredPolicyItems.size(), "Grants for Principals: " + Arrays.toString(requestedPrincipals) + " and AccessTypes: " + Arrays.toString(requestedAccessTypes) + " should exist");
+ assertTrue(filteredPolicyItems.get(0).getUsers().contains("hive"), "Grants for Principals: " + Arrays.toString(requestedPrincipals) + "should exist");
+ assertTrue(filteredPolicyItems.get(0).getAccesses().stream().anyMatch(x -> Arrays.asList(requestedAccessTypes).contains(x.getType())), "Grants for AccessTypes: " + Arrays.toString(requestedAccessTypes) + "should exist");
String[] nonexistentRequestedAccessTypes = {"_DELETE"};
when(searchUtil.getParamMultiValues(request, "accessType")).thenReturn(nonexistentRequestedAccessTypes);
List<RangerPolicy.RangerPolicyItem> updatedPolicyItemsByAccessType = new ArrayList<>(gdsREST.filterPolicyItemsByRequest(policy, request));
- assertTrue("Grants for Principals: " + Arrays.toString(requestedPrincipals) + " and AccessTypes: " + Arrays.toString(nonexistentRequestedAccessTypes) + " should be empty", updatedPolicyItemsByAccessType.isEmpty());
+ assertTrue(updatedPolicyItemsByAccessType.isEmpty(), "Grants for Principals: " + Arrays.toString(requestedPrincipals) + " and AccessTypes: " + Arrays.toString(nonexistentRequestedAccessTypes) + " should be empty");
}
@Test
@@ -257,10 +1638,9 @@ public void testSearchDataSetsByValidityPeriod() {
gdsDBStore.filterDatasetsByValidityExpiration(filter, actualDatasets);
- assertEquals("Datasets expiry count mismatch between " + startTime + " and " + endTime, expectedDatasets.size(), actualDatasets.size());
+ assertEquals(expectedDatasets.size(), actualDatasets.size(), "Datasets expiry count mismatch between " + startTime + " and " + endTime);
- assertTrue("Mismatch in datasets returned for expiry between " + startTime + " and " + endTime,
- actualDatasets.containsAll(expectedDatasets));
+ assertTrue(actualDatasets.containsAll(expectedDatasets), "Mismatch in datasets returned for expiry between " + startTime + " and " + endTime);
//ValiditySchedule Filter criteria-2
actualDatasets.clear();
@@ -275,10 +1655,9 @@ public void testSearchDataSetsByValidityPeriod() {
gdsDBStore.filterDatasetsByValidityExpiration(filter, actualDatasets);
- assertEquals("Datasets expiry count mismatch between " + startTime + " and " + endTime, expectedDatasets.size(), actualDatasets.size());
+ assertEquals(expectedDatasets.size(), actualDatasets.size(), "Datasets expiry count mismatch between " + startTime + " and " + endTime);
- assertTrue("Mismatch in datasets returned for expiry between " + startTime + " and " + endTime,
- actualDatasets.containsAll(expectedDatasets));
+ assertTrue(actualDatasets.containsAll(expectedDatasets), "Mismatch in datasets returned for expiry between " + startTime + " and " + endTime);
//ValiditySchedule Filter criteria-3
actualDatasets.clear();
@@ -293,10 +1672,9 @@ public void testSearchDataSetsByValidityPeriod() {
gdsDBStore.filterDatasetsByValidityExpiration(filter, actualDatasets);
- assertEquals("Datasets expiry count mismatch between " + startTime + " and " + endTime, expectedDatasets.size(), actualDatasets.size());
+ assertEquals(expectedDatasets.size(), actualDatasets.size(), "Datasets expiry count mismatch between " + startTime + " and " + endTime);
- assertTrue("Mismatch in datasets returned for expiry between " + startTime + " and " + endTime,
- actualDatasets.containsAll(expectedDatasets));
+ assertTrue(actualDatasets.containsAll(expectedDatasets), "Mismatch in datasets returned for expiry between " + startTime + " and " + endTime);
//ValiditySchedule Filter criteria-4 with invalid date
actualDatasets.clear();
@@ -324,13 +1702,13 @@ public void testSearchDataSetsByValidityPeriod() {
gdsDBStore.filterDatasetsByValidityExpiration(filter, actualDatasets);
- assertEquals("Datasets expiry count mismatch with empty start and end time", expectedDatasets.size(), actualDatasets.size());
+ assertEquals(expectedDatasets.size(), actualDatasets.size(), "Datasets expiry count mismatch with empty start and end time");
- assertTrue("Mismatch in datasets returned with empty expiry time range", actualDatasets.containsAll(expectedDatasets));
+ assertTrue(actualDatasets.containsAll(expectedDatasets), "Mismatch in datasets returned with empty expiry time range");
}
private RangerGds.RangerDataset createRangerDataSet() {
- long id = new Random().nextInt(100);
+ long id = random.nextInt(100);
RangerGds.RangerDataset dataset = new RangerGds.RangerDataset();
dataset.setId(id);
dataset.setName("dataset-" + id);
@@ -339,6 +1717,80 @@ private RangerGds.RangerDataset createRangerDataSet() {
return dataset;
}
+ private RangerGds.RangerProject createProject() {
+ long id = random.nextInt(100);
+ RangerGds.RangerProject project = new RangerGds.RangerProject();
+ project.setId(id);
+ project.setName("project-" + id);
+ project.setGuid(UUID.randomUUID().toString());
+
+ return project;
+ }
+
+ private RangerGds.RangerDataShare createDataShare() {
+ long id = random.nextInt(100);
+ RangerGds.RangerDataShare dataShare = new RangerGds.RangerDataShare();
+ dataShare.setId(id);
+ dataShare.setName("dataShare-" + id);
+ dataShare.setGuid(UUID.randomUUID().toString());
+ dataShare.setService(serviceHive);
+
+ return dataShare;
+ }
+
+ private RangerGds.RangerSharedResource createSharedResource() {
+ long id = random.nextInt(100);
+ RangerGds.RangerSharedResource sharedResource = new RangerGds.RangerSharedResource();
+ sharedResource.setId(id);
+ sharedResource.setName("resource-" + id);
+ sharedResource.setGuid(UUID.randomUUID().toString());
+ sharedResource.setResource(createRandomResources(serviceDefHive, "test"));
+
+ return sharedResource;
+ }
+
+ private Map<String, RangerPolicy.RangerPolicyResource> createRandomResources(String service, String prefix) {
+ Map<String, RangerPolicy.RangerPolicyResource> resources = new HashMap<>();
+ int id = random.nextInt(50);
+
+ if (serviceDefHive.equals(service)) {
+ resources.put("database", new RangerPolicy.RangerPolicyResource(prefix + "_db_" + id, false, false));
+ resources.put("table", new RangerPolicy.RangerPolicyResource(prefix + "_tb_" + id, false, false));
+ resources.put("column", new RangerPolicy.RangerPolicyResource(prefix + "_col_" + id, false, false));
+ } else {
+ resources.put("tag", new RangerPolicy.RangerPolicyResource(prefix + "_tag_" + id, false, false));
+ }
+ return resources;
+ }
+
+ private RangerGds.RangerDataShareInDataset createDataShareInDataset(Long datasetId) {
+ RangerGds.RangerDataShareInDataset dataShareInDataset = new RangerGds.RangerDataShareInDataset();
+ dataShareInDataset.setDatasetId(datasetId);
+ dataShareInDataset.setDataShareId(1L);
+ dataShareInDataset.setStatus(RangerGds.GdsShareStatus.ACTIVE);
+
+ return dataShareInDataset;
+ }
+
+ private RangerGds.RangerDatasetInProject createDatasetInProject() {
+ RangerGds.RangerDatasetInProject datasetInProject = new RangerGds.RangerDatasetInProject();
+ datasetInProject.setDatasetId(1L);
+ datasetInProject.setProjectId(1L);
+ datasetInProject.setStatus(RangerGds.GdsShareStatus.ACTIVE);
+
+ return datasetInProject;
+ }
+
+ private RangerPolicy createPolicy() {
+ RangerPolicy policy = new RangerPolicy();
+ policy.setId((long) random.nextInt(100));
+ policy.setName("policy-" + policy.getId());
+ policy.setServiceType("gds");
+ policy.setService("_gds");
+
+ return policy;
+ }
+
private RangerGds.RangerDataset updateDatasetValiditySchedule(RangerGds.RangerDataset dataset, int pastDaysToStart, int futureDaysToEnd) {
String start = getFormattedDateString(pastDaysToStart);
String end = getFormattedDateString(futureDaysToEnd);
@@ -402,4 +1854,637 @@ private List<RangerGrant> createAndGetSampleGrantData() {
return Arrays.asList(grant1, grant2);
}
+
+ @Test
+ public void testAddSharedResource() {
+ RangerGds.RangerSharedResource resource = createSharedResource();
+ RangerGds.RangerSharedResource stored = createSharedResource();
+ stored.setId(100L);
+
+ when(gdsStore.addSharedResources(Mockito.anyList())).thenReturn(Collections.singletonList(stored));
+
+ RangerGds.RangerSharedResource result = gdsREST.addSharedResource(resource);
+
+ assertNotNull(result);
+ assertEquals(Long.valueOf(100L), result.getId());
+ verify(gdsStore).addSharedResources(Mockito.anyList());
+ }
+
+ @Test
+ public void testAddSharedResourceException() {
+ RangerGds.RangerSharedResource resource = createSharedResource();
+
+ when(gdsStore.addSharedResources(Mockito.anyList())).thenThrow(new RuntimeException("DB error"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.addSharedResource(resource));
+ }
+
+ @Test
+ public void testAddDatasetResourcesWithExistingDataShare() throws Exception {
+ Long datasetId = 10L;
+ String serviceNm = "svc1";
+ String zoneName = "";
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(5L);
+ rangerService.setIsEnabled(true);
+
+ RangerGds.RangerDataset dataset = createRangerDataSet();
+ dataset.setId(datasetId);
+
+ RangerGds.RangerDataShare existingShare = createDataShare();
+ existingShare.setId(77L);
+ PList<RangerGds.RangerDataShare> dataSharePList = new PList<>();
+ dataSharePList.setList(Arrays.asList(existingShare));
+
+ RangerGds.RangerSharedResource r1 = createSharedResource();
+ RangerGds.RangerSharedResource r2 = createSharedResource();
+ RangerGds.RangerSharedResource r1Stored = createSharedResource();
+ r1Stored.setId(201L);
+ RangerGds.RangerSharedResource r2Stored = createSharedResource();
+ r2Stored.setId(202L);
+
+ when(serviceDBStore.getServiceByName(serviceNm)).thenReturn(rangerService);
+ when(gdsStore.getDataset(datasetId)).thenReturn(dataset);
+ when(gdsStore.searchDataShares(any(SearchFilter.class))).thenReturn(dataSharePList);
+ when(gdsStore.addSharedResources(Mockito.anyList()))
+ .thenReturn(Collections.singletonList(r1Stored))
+ .thenReturn(Collections.singletonList(r2Stored));
+
+ List<RangerGds.RangerSharedResource> result = gdsREST.addDatasetResources(datasetId, serviceNm, zoneName, Arrays.asList(r1, r2));
+
+ assertNotNull(result);
+ assertEquals(2, result.size());
+ assertEquals(Long.valueOf(201L), result.get(0).getId());
+ assertEquals(Long.valueOf(202L), result.get(1).getId());
+ verify(serviceDBStore).getServiceByName(serviceNm);
+ verify(gdsStore).getDataset(datasetId);
+ verify(gdsStore, Mockito.times(2)).addSharedResources(Mockito.anyList());
+ }
+
+ @Test
+ public void testAddDatasetResourcesCreatesNewDataShare() throws Exception {
+ Long datasetId = 20L;
+ String serviceNm = "svc2";
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(6L);
+ rangerService.setIsEnabled(true);
+
+ RangerGds.RangerDataset dataset = createRangerDataSet();
+ dataset.setId(datasetId);
+
+ PList<RangerGds.RangerDataShare> emptyPList = new PList<>();
+ emptyPList.setList(new ArrayList<>());
+
+ RangerGds.RangerDataShare createdShare = createDataShare();
+ createdShare.setId(88L);
+
+ RangerGds.RangerSharedResource res = createSharedResource();
+ RangerGds.RangerSharedResource resStored = createSharedResource();
+ resStored.setId(301L);
+
+ when(serviceDBStore.getServiceByName(serviceNm)).thenReturn(rangerService);
+ when(gdsStore.getDataset(datasetId)).thenReturn(dataset);
+ when(gdsStore.searchDataShares(any(SearchFilter.class))).thenReturn(emptyPList);
+ when(gdsStore.createDataShare(any(RangerGds.RangerDataShare.class))).thenReturn(createdShare);
+ when(gdsStore.addDataSharesInDataset(any(List.class))).thenAnswer(invocation -> invocation.getArgument(0));
+ when(gdsStore.addSharedResources(Mockito.anyList())).thenReturn(Collections.singletonList(resStored));
+
+ List<RangerGds.RangerSharedResource> result = gdsREST.addDatasetResources(datasetId, serviceNm, "", Collections.singletonList(res));
+
+ assertNotNull(result);
+ assertEquals(1, result.size());
+ assertEquals(Long.valueOf(301L), result.get(0).getId());
+ verify(gdsStore).createDataShare(any(RangerGds.RangerDataShare.class));
+ verify(gdsStore).addDataSharesInDataset(any(List.class));
+ }
+
+ @Test
+ public void testAddDatasetResourcesServiceNameMissing() {
+ when(restErrorUtil.createRESTException(eq("ServiceName not provided."), eq(MessageEnums.INVALID_INPUT_DATA))).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.addDatasetResources(1L, "", "", Collections.singletonList(createSharedResource())));
+ }
+
+ @Test
+ public void testAddDatasetResourcesServiceDisabled() throws Exception {
+ String serviceNm = "svc3";
+ RangerService rangerService = new RangerService();
+ rangerService.setId(7L);
+ rangerService.setIsEnabled(false);
+
+ when(serviceDBStore.getServiceByName(serviceNm)).thenReturn(rangerService);
+ when(restErrorUtil.createRESTException(eq("Unauthorized access."), eq(MessageEnums.OPER_NOT_ALLOWED_FOR_STATE))).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.addDatasetResources(1L, serviceNm, "", Collections.singletonList(createSharedResource())));
+ }
+
+ @Test
+ public void testAddDatasetResourcesZoneNotFound() throws Exception {
+ String serviceNm = "svc4";
+ String zoneName = "zoneA";
+ RangerService rangerService = new RangerService();
+ rangerService.setId(8L);
+ rangerService.setIsEnabled(true);
+
+ when(serviceDBStore.getServiceByName(serviceNm)).thenReturn(rangerService);
+ Mockito.doThrow(new RuntimeException("Zone not found")).when(serviceDBStore).getSecurityZone(zoneName);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), eq(MessageEnums.DATA_NOT_FOUND))).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.addDatasetResources(1L, serviceNm, zoneName, Collections.singletonList(createSharedResource())));
+ }
+
+ @Test
+ public void testAddDatasetResourcesServiceNotFound() throws Exception {
+ String serviceNm = "svc-missing";
+
+ Mockito.doThrow(new Exception("Service not found")).when(serviceDBStore).getServiceByName(serviceNm);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), eq(MessageEnums.DATA_NOT_FOUND))).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.addDatasetResources(1L, serviceNm, "", Collections.singletonList(createSharedResource())));
+ }
+
+ @Test
+ public void testAddDatasetResourcesServiceNull() throws Exception {
+ String serviceNm = "svc-null";
+
+ Mockito.doThrow(new Exception("Service missing")).when(serviceDBStore).getServiceByName(serviceNm);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), eq(MessageEnums.DATA_NOT_FOUND)))
+ .thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.addDatasetResources(1L, serviceNm, "", Collections.singletonList(createSharedResource())));
+ }
+
+ @Test
+ public void testAddDatasetResourcesSetsDataShareIdOnResources() throws Exception {
+ Long datasetId = 30L;
+ String serviceNm = "svc5";
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(9L);
+ rangerService.setIsEnabled(true);
+
+ RangerGds.RangerDataset dataset = createRangerDataSet();
+ dataset.setId(datasetId);
+
+ RangerGds.RangerDataShare existingShare = createDataShare();
+ existingShare.setId(777L);
+ PList<RangerGds.RangerDataShare> dataSharePList = new PList<>();
+ dataSharePList.setList(Arrays.asList(existingShare));
+
+ RangerGds.RangerSharedResource res = createSharedResource();
+ RangerGds.RangerSharedResource resStored = createSharedResource();
+ resStored.setId(401L);
+
+ when(serviceDBStore.getServiceByName(serviceNm)).thenReturn(rangerService);
+ when(gdsStore.getDataset(datasetId)).thenReturn(dataset);
+ when(gdsStore.searchDataShares(any(SearchFilter.class))).thenReturn(dataSharePList);
+ when(gdsStore.addSharedResources(Mockito.anyList())).thenReturn(Collections.singletonList(resStored));
+
+ ArgumentCaptor<List<RangerGds.RangerSharedResource>> captor = ArgumentCaptor.forClass(List.class);
+
+ List<RangerGds.RangerSharedResource> result = gdsREST.addDatasetResources(datasetId, serviceNm, "", Collections.singletonList(res));
+
+ assertNotNull(result);
+ verify(gdsStore).addSharedResources(captor.capture());
+ List<RangerGds.RangerSharedResource> passed = captor.getValue();
+ assertEquals(1, passed.size());
+ assertEquals(Long.valueOf(777L), passed.get(0).getDataShareId());
+ }
+
+ @Test
+ public void testAddDataSharesInDatasetEmptyList() {
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_BAD_REQUEST), anyString(), eq(false)))
+ .thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.addDataSharesInDataset(1L, Collections.emptyList()));
+ }
+
+ @Test
+ public void testAddDatasetResourcesGenericException() throws Exception {
+ Long datasetId = 40L;
+ String serviceNm = "svc-ex";
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(10L);
+ rangerService.setIsEnabled(true);
+
+ when(serviceDBStore.getServiceByName(serviceNm)).thenReturn(rangerService);
+ when(gdsStore.getDataset(datasetId)).thenThrow(new RuntimeException("boom"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class,
+ () -> gdsREST.addDatasetResources(datasetId, serviceNm, "", Collections.singletonList(createSharedResource())));
+ }
+
+ @Test
+ public void testRemoveMatchingPrincipalFromPolicyItem_viaReflection() throws Exception {
+ RangerPolicy.RangerPolicyItem item = new RangerPolicy.RangerPolicyItem();
+ item.setUsers(new ArrayList<>(Collections.singletonList("u1")));
+ item.setGroups(new ArrayList<>(Collections.singletonList("g1")));
+ item.setRoles(new ArrayList<>(Collections.singletonList("r1")));
+
+ Method m = GdsREST.class.getDeclaredMethod("removeMatchingPrincipalFromPolicyItem", RangerPolicy.RangerPolicyItem.class, RangerPrincipal.class);
+ m.setAccessible(true);
+
+ m.invoke(gdsREST, item, new RangerPrincipal(RangerPrincipal.PrincipalType.USER, "u1"));
+ assertTrue(item.getUsers() == null || item.getUsers().isEmpty());
+
+ item.setUsers(new ArrayList<>(Collections.singletonList("u2")));
+ m.invoke(gdsREST, item, new RangerPrincipal(RangerPrincipal.PrincipalType.GROUP, "g1"));
+ assertTrue(item.getGroups() == null || item.getGroups().isEmpty());
+
+ m.invoke(gdsREST, item, new RangerPrincipal(RangerPrincipal.PrincipalType.ROLE, "r1"));
+ assertTrue(item.getRoles() == null || item.getRoles().isEmpty());
+ }
+
+ @Test
+ public void testValidateAndGetZoneId_defaultUnzoned() throws Exception {
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetZoneId", String.class);
+ m.setAccessible(true);
+
+ Long ret = (Long) m.invoke(gdsREST, "");
+ assertEquals(Long.valueOf(RangerSecurityZone.RANGER_UNZONED_SECURITY_ZONE_ID), ret);
+ }
+
+ @Test
+ public void testValidateAndGetZoneId_found() throws Exception {
+ String zoneName = "zoneX";
+ RangerSecurityZone zone = new RangerSecurityZone();
+ zone.setId(55L);
+ when(serviceDBStore.getSecurityZone(zoneName)).thenReturn(zone);
+
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetZoneId", String.class);
+ m.setAccessible(true);
+ Long ret = (Long) m.invoke(gdsREST, zoneName);
+ assertEquals(Long.valueOf(55L), ret);
+ }
+
+ @Test
+ public void testValidateAndGetZoneId_notFoundException() throws Exception {
+ String zoneName = "zoneY";
+ when(serviceDBStore.getSecurityZone(zoneName)).thenThrow(new RuntimeException("not found"));
+ when(restErrorUtil.createRESTException(anyString(), eq(MessageEnums.DATA_NOT_FOUND))).thenReturn(new WebApplicationException());
+
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetZoneId", String.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(gdsREST, zoneName);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testValidateAndGetZoneId_nullZone() throws Exception {
+ String zoneName = "zoneZ";
+
+ when(serviceDBStore.getSecurityZone(zoneName)).thenThrow(new RuntimeException("no zone"));
+ when(restErrorUtil.createRESTException(anyString(), eq(MessageEnums.DATA_NOT_FOUND))).thenReturn(new WebApplicationException());
+
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetZoneId", String.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(gdsREST, zoneName);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testValidateAndGetServiceId_nullName() throws Exception {
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetServiceId", String.class);
+ m.setAccessible(true);
+ when(restErrorUtil.createRESTException(eq("ServiceName not provided."), eq(MessageEnums.INVALID_INPUT_DATA))).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(gdsREST, "");
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testValidateAndGetServiceId_found() throws Exception {
+ String serviceNm = "svcX";
+ RangerService svc = new RangerService();
+ svc.setId(99L);
+ svc.setIsEnabled(true);
+ when(serviceDBStore.getServiceByName(serviceNm)).thenReturn(svc);
+
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetServiceId", String.class);
+ m.setAccessible(true);
+ Long ret = (Long) m.invoke(gdsREST, serviceNm);
+ assertEquals(Long.valueOf(99L), ret);
+ }
+
+ @Test
+ public void testValidateAndGetServiceId_serviceThrows() throws Exception {
+ String serviceNm = "svcY";
+ when(serviceDBStore.getServiceByName(serviceNm)).thenThrow(new RuntimeException("no svc"));
+ when(restErrorUtil.createRESTException(eq("Service:" + serviceNm + " not found"), eq(MessageEnums.DATA_NOT_FOUND))).thenReturn(new WebApplicationException());
+
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetServiceId", String.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(gdsREST, serviceNm);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testValidateAndGetServiceId_nullService() throws Exception {
+ String serviceNm = "svcZ";
+
+ when(serviceDBStore.getServiceByName(serviceNm)).thenThrow(new RuntimeException("no svc"));
+ when(restErrorUtil.createRESTException(eq("Service:" + serviceNm + " not found"), eq(MessageEnums.DATA_NOT_FOUND))).thenReturn(new WebApplicationException());
+
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetServiceId", String.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(gdsREST, serviceNm);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testValidateAndGetServiceId_disabledService() throws Exception {
+ String serviceNm = "svcD";
+ RangerService svc = new RangerService();
+ svc.setId(100L);
+ svc.setIsEnabled(false);
+ when(serviceDBStore.getServiceByName(serviceNm)).thenReturn(svc);
+ when(restErrorUtil.createRESTException(eq("Unauthorized access."), eq(MessageEnums.OPER_NOT_ALLOWED_FOR_STATE))).thenReturn(new WebApplicationException());
+
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetServiceId", String.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(gdsREST, serviceNm);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testUpdateDataSetGrants_NoPolicyExists() throws Exception {
+ Long datasetId = 42L;
+ List<RangerGrant> rangerGrants = createAndGetSampleGrantData();
+ RangerPolicy newPolicy = new RangerPolicy();
+ newPolicy.setId(7L);
+ RangerPolicy updatedPolicy = createPolicyForDataSet(createRangerDataSet());
+ updatedPolicy.setId(7L);
+
+ when(gdsStore.getDatasetPolicies(datasetId)).thenReturn(Collections.emptyList());
+ when(gdsStore.addDatasetPolicy(eq(datasetId), any(RangerPolicy.class))).thenReturn(newPolicy);
+ when(gdsStore.updateDatasetPolicy(eq(datasetId), any(RangerPolicy.class))).thenReturn(updatedPolicy);
+
+ RangerPolicyHeader result = gdsREST.updateDataSetGrants(datasetId, rangerGrants);
+ assertNotNull(result);
+ assertEquals(updatedPolicy.getId(), result.getId());
+ verify(gdsStore).addDatasetPolicy(eq(datasetId), any(RangerPolicy.class));
+ verify(gdsStore).updateDatasetPolicy(eq(datasetId), any(RangerPolicy.class));
+ }
+
+ @Test
+ public void testListProjectNamesException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getProjectNames(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.listProjectNames(request));
+ }
+
+ @Test
+ public void testListDatasetNamesException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getDatasetNames(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.listDatasetNames(request));
+ }
+
+ @Test
+ public void testGetServiceGdsInfoIfUpdated_NotModified() throws Exception {
+ String serviceName = "svc-nomod";
+ Long lastKnownVersion = 5L;
+ String pluginId = "p1";
+ String clusterName = "c1";
+ String pluginCapabilities = "caps";
+
+ doNothing().when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
+ when(gdsStore.getGdsInfoIfUpdated(serviceName, lastKnownVersion)).thenReturn(null);
+ doNothing().when(assetMgr).createPluginInfo(anyString(), anyString(), any(HttpServletRequest.class), anyInt(), any(), any(), anyLong(), anyInt(), anyString(), anyString());
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_NOT_MODIFIED), anyString(), eq(false))).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () ->
+ gdsREST.getServiceGdsInfoIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, clusterName, pluginCapabilities, request));
+ }
+
+ @Test
+ public void testGetServiceGdsInfoIfUpdated_AuthInvalidReturnsNull() throws Exception {
+ String serviceName = "svc-auth-invalid";
+ Long lastKnownVersion = 1L;
+
+ doNothing().when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(false);
+ doNothing().when(assetMgr).createPluginInfo(anyString(), anyString(), any(HttpServletRequest.class), anyInt(), any(), any(), anyLong(), anyInt(), anyString(), anyString());
+
+ ServiceGdsInfo result = gdsREST.getServiceGdsInfoIfUpdated(serviceName, lastKnownVersion, 0L, "p1", "c1", "caps", request);
+ assertEquals(null, result);
+ }
+
+ @Test
+ public void testGetSecureServiceGdsInfoIfUpdated_NotModified() throws Exception {
+ String serviceName = "svc-secure-nomod";
+ Long lastKnownVersion = 7L;
+
+ doNothing().when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
+ when(gdsStore.getGdsInfoIfUpdated(serviceName, lastKnownVersion)).thenReturn(null);
+ doNothing().when(assetMgr).createPluginInfo(anyString(), anyString(), any(HttpServletRequest.class), anyInt(), any(), any(), anyLong(), anyInt(), anyString(), anyString());
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_NOT_MODIFIED), anyString(), eq(false))).thenReturn(new WebApplicationException());
+
+ assertThrows(WebApplicationException.class, () ->
+ gdsREST.getSecureServiceGdsInfoIfUpdated(serviceName, lastKnownVersion, 0L, "p1", "c1", "caps", request));
+ }
+
+ @Test
+ public void testFilterPolicyItemsByRequest_DefaultPrincipalType() {
+ RangerGds.RangerDataset dataset = createRangerDataSet();
+ RangerPolicy policy = createPolicyForDataSet(dataset);
+ RangerGrant grant = new RangerGrant(new RangerPrincipal(RangerPrincipal.PrincipalType.USER, "hive"), Collections.singletonList("_READ"), Collections.emptyList());
+
+ policy = gdsREST.updatePolicyWithModifiedGrants(policy, Collections.singletonList(grant));
+
+ when(searchUtil.getParamMultiValues(request, "principal")).thenReturn(new String[] {"hive"});
+
+ List<RangerPolicy.RangerPolicyItem> filtered = new ArrayList<>(gdsREST.filterPolicyItemsByRequest(policy, request));
+ assertEquals(1, filtered.size());
+ assertTrue(filtered.get(0).getUsers().contains("hive"));
+ }
+
+ @Test
+ public void testSearchDatasets_ExtractsMultiValueParams() {
+ PList<RangerGds.RangerDataset> expected = new PList<>();
+ expected.setList(Arrays.asList(createRangerDataSet()));
+ SearchFilter filter = new SearchFilter();
+
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.searchDatasets(filter)).thenReturn(expected);
+
+ PList<RangerGds.RangerDataset> result = gdsREST.searchDatasets(request);
+ assertNotNull(result);
+
+ verify(searchUtil, Mockito.times(1)).extractStringList(eq(request), eq(filter), eq(SearchFilter.DATASET_LABEL), anyString(), anyString(), any(), any());
+ verify(searchUtil, Mockito.times(1)).extractStringList(eq(request), eq(filter), eq(SearchFilter.DATASET_KEYWORD), anyString(), anyString(), any(), any());
+ }
+
+ @Test
+ public void testUpdateDataSetGrants_NoActionPerformed() throws Exception {
+ Long datasetId = 99L;
+ RangerPolicy policy = createPolicyForDataSet(createRangerDataSet());
+ RangerPolicy existing = createPolicyForDataSet(createRangerDataSet());
+ existing.setId(12L);
+ existing.setPolicyItems(policy.getPolicyItems());
+
+ when(gdsStore.getDatasetPolicies(datasetId)).thenReturn(Collections.singletonList(existing));
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_NOT_MODIFIED), anyString(), eq(false))).thenReturn(new WebApplicationException());
+
+ List<RangerGrant> grants = Collections.singletonList(new RangerGrant(new RangerPrincipal(RangerPrincipal.PrincipalType.USER, "nouser"), Collections.emptyList(), Collections.emptyList()));
+
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateDataSetGrants(datasetId, grants));
+ }
+
+ @Test
+ public void testAddDataSharesInDataset_MissingDatasetId() {
+ Long datasetId = 1L;
+ RangerGds.RangerDataShareInDataset item = new RangerGds.RangerDataShareInDataset();
+ item.setDatasetId(null);
+ item.setDataShareId(2L);
+ item.setStatus(RangerGds.GdsShareStatus.ACTIVE);
+ when(restErrorUtil.createRESTException(eq(HttpServletResponse.SC_BAD_REQUEST), anyString(), eq(false)))
+ .thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.addDataSharesInDataset(datasetId, Arrays.asList(item)));
+ }
+
+ @Test
+ public void testAddDataSharesInDataset_GenericException() throws Exception {
+ Long datasetId = 1L;
+ RangerGds.RangerDataShareInDataset item = createDataShareInDataset(datasetId);
+ when(gdsStore.addDataSharesInDataset(Mockito.anyList())).thenThrow(new RuntimeException("boom"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.addDataSharesInDataset(datasetId, Arrays.asList(item)));
+ }
+
+ @Test
+ public void testGetDatasetSummaryException() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getDatasetSummary(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.getDatasetSummary(request));
+ }
+
+ @Test
+ public void testGetEnhancedDatasetSummaryException2() {
+ SearchFilter filter = new SearchFilter();
+ when(searchUtil.getSearchFilter(request, datasetService.sortFields)).thenReturn(filter);
+ when(gdsStore.getEnhancedDatasetSummary(filter)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.getEnhancedDatasetSummary(request));
+ }
+
+ @Test
+ public void testAddProjectPolicyException2() throws Exception {
+ Long projectId = 123L;
+ RangerPolicy policy = createPolicy();
+ when(gdsStore.addProjectPolicy(projectId, policy)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.addProjectPolicy(projectId, policy));
+ }
+
+ @Test
+ public void testUpdateProjectPolicyException2() throws Exception {
+ Long projectId = 123L;
+ Long policyId = 999L;
+ RangerPolicy policy = createPolicy();
+ when(gdsStore.updateProjectPolicy(eq(projectId), any(RangerPolicy.class))).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateProjectPolicy(projectId, policyId, policy));
+ }
+
+ @Test
+ public void testAddSharedResources_BatchSizeExceeded() {
+ List<RangerGds.RangerSharedResource> resources = new ArrayList<>();
+ for (int i = 0; i < 101; i++) {
+ resources.add(createSharedResource());
+ }
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.addSharedResources(resources));
+ }
+
+ @Test
+ public void testUpdateDataSetGrants_GenericException2() {
+ Long datasetId = 77L;
+ when(gdsStore.getDatasetPolicies(datasetId)).thenThrow(new RuntimeException("err"));
+ when(restErrorUtil.createRESTException(anyString())).thenReturn(new WebApplicationException());
+ assertThrows(WebApplicationException.class, () -> gdsREST.updateDataSetGrants(datasetId, Collections.emptyList()));
+ }
+
+ @Test
+ public void testValidateAndGetServiceId_serviceNull404() throws Exception {
+ String serviceNm = "svcNull";
+ when(serviceDBStore.getServiceByName(serviceNm)).thenThrow(new RuntimeException("no svc"));
+ when(restErrorUtil.createRESTException(eq("Service:" + serviceNm + " not found"), eq(MessageEnums.DATA_NOT_FOUND))).thenReturn(new WebApplicationException());
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetServiceId", String.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(gdsREST, serviceNm);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testValidateAndGetZoneId_zoneNull404() throws Exception {
+ String zoneName = "zoneNull";
+ when(serviceDBStore.getSecurityZone(zoneName)).thenThrow(new RuntimeException("no zone"));
+ when(restErrorUtil.createRESTException(eq("Zone:" + zoneName + " not found"), eq(MessageEnums.DATA_NOT_FOUND))).thenReturn(new WebApplicationException());
+ Method m = GdsREST.class.getDeclaredMethod("validateAndGetZoneId", String.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(gdsREST, zoneName);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
}
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestMetricsREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestMetricsREST.java
index efcbff603..4098975e8 100644
--- a/security-admin/src/test/java/org/apache/ranger/rest/TestMetricsREST.java
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestMetricsREST.java
@@ -19,23 +19,38 @@
package org.apache.ranger.rest;
+import org.apache.ranger.metrics.RangerAdminMetricsWrapper;
import org.apache.ranger.plugin.model.RangerMetrics;
import org.apache.ranger.util.RangerMetricsUtil;
-import org.junit.Assert;
-import org.junit.FixMethodOrder;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
+import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
-@RunWith(MockitoJUnitRunner.class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+* @generated by Cursor
+* @description <Unit Test for TestMetricsREST class>
+*/
+@ExtendWith(MockitoExtension.class)
+@TestMethodOrder(MethodOrderer.MethodName.class)
public class TestMetricsREST {
@InjectMocks
MetricsREST metricsREST = new MetricsREST();
@@ -43,31 +58,151 @@ public class TestMetricsREST {
@Mock
RangerMetricsUtil jvmMetricUtil;
+ @Mock
+ RangerAdminMetricsWrapper rangerAdminMetricsWrapper;
+
@Test
- public void testGetStatus() {
+ public void testGetStatus() throws Exception {
Map<String, Object> rangerMetricsValues = getRangerMetricsValues();
Mockito.when(jvmMetricUtil.getValues()).thenReturn(rangerMetricsValues);
RangerMetrics rangerMetrics = metricsREST.getStatus();
- Assert.assertNotNull(rangerMetrics);
- Assert.assertNotNull(rangerMetrics.getData());
- Assert.assertNotNull(rangerMetrics.getData().get("jvm"));
+ Assertions.assertNotNull(rangerMetrics);
+ Assertions.assertNotNull(rangerMetrics.getData());
+ Assertions.assertNotNull(rangerMetrics.getData().get("jvm"));
Map<String, Object> jvmMetricsMap = (Map<String, Object>) rangerMetrics.getData().get("jvm");
- Assert.assertNotNull(jvmMetricsMap.get("JVM Machine Actual Name"));
- Assert.assertNotNull(jvmMetricsMap.get("version"));
- Assert.assertNotNull(jvmMetricsMap.get("JVM Vendor Name"));
- Assert.assertEquals("Mac OS X, x86_64, 12.6.3", jvmMetricsMap.get("os.spec"));
- Assert.assertEquals("8", jvmMetricsMap.get("os.vcpus"));
- Assert.assertNotNull(jvmMetricsMap.get("memory"));
+ Assertions.assertNotNull(jvmMetricsMap.get("JVM Machine Actual Name"));
+ Assertions.assertNotNull(jvmMetricsMap.get("version"));
+ Assertions.assertNotNull(jvmMetricsMap.get("JVM Vendor Name"));
+ Assertions.assertEquals("Mac OS X, x86_64, 12.6.3", jvmMetricsMap.get("os.spec"));
+ Assertions.assertEquals("8", jvmMetricsMap.get("os.vcpus"));
+ Assertions.assertNotNull(jvmMetricsMap.get("memory"));
Map<String, Object> memoryDetailsMap = (Map<String, Object>) jvmMetricsMap.get("memory");
- Assert.assertEquals("7635730432", memoryDetailsMap.get("heapMax"));
- Assert.assertEquals("40424768", memoryDetailsMap.get("heapUsed"));
+ Assertions.assertEquals("7635730432", memoryDetailsMap.get("heapMax"));
+ Assertions.assertEquals("40424768", memoryDetailsMap.get("heapUsed"));
+ }
+
+ @Test
+ public void testGetStatus_ExceptionInJvmMetrics() throws Exception {
+ when(jvmMetricUtil.getValues()).thenThrow(new RuntimeException("JVM metrics exception"));
+
+ assertThrows(RuntimeException.class, () -> metricsREST.getStatus());
+
+ verify(jvmMetricUtil, times(1)).getValues();
+ }
+
+ @Test
+ public void testGetStatus_NullJvmMetrics() throws Exception {
+ when(jvmMetricUtil.getValues()).thenReturn(null);
+
+ assertThrows(NullPointerException.class, () -> metricsREST.getStatus());
+ }
+
+ @Test
+ public void testGetStatus_EmptyJvmMetrics() throws Exception {
+ when(jvmMetricUtil.getValues()).thenReturn(new HashMap<>());
+
+ RangerMetrics result = metricsREST.getStatus();
+
+ assertNotNull(result);
+ assertNotNull(result.getData());
+ assertNotNull(result.getData().get("jvm"));
+
+ Map<String, Object> jvmMetricsMap = (Map<String, Object>) result.getData().get("jvm");
+
+ assertNotNull(jvmMetricsMap.get("JVM Machine Actual Name"));
+ assertNotNull(jvmMetricsMap.get("version"));
+ assertNotNull(jvmMetricsMap.get("JVM Vendor Name"));
+ assertNotNull(jvmMetricsMap.get("Up time of JVM"));
+
+ verify(jvmMetricUtil, times(1)).getValues();
+ }
+
+ @Test
+ public void testGetMetricsPrometheus_Success() throws Exception {
+ String expectedPrometheusMetrics = "jvm_memory_used_bytes{area=\"heap\"} 40424768\n" +
+ "jvm_memory_used_bytes{area=\"nonheap\"} 123456789\n";
+
+ when(rangerAdminMetricsWrapper.getRangerMetricsInPrometheusFormat()).thenReturn(expectedPrometheusMetrics);
+
+ String result = metricsREST.getMetricsPrometheus();
+
+ assertNotNull(result);
+ assertEquals(expectedPrometheusMetrics, result);
+ verify(rangerAdminMetricsWrapper, times(1)).getRangerMetricsInPrometheusFormat();
+ }
+
+ @Test
+ public void testGetMetricsPrometheus_Exception() throws Exception {
+ when(rangerAdminMetricsWrapper.getRangerMetricsInPrometheusFormat()).thenThrow(new RuntimeException("Metrics exception"));
+
+ String result = metricsREST.getMetricsPrometheus();
+
+ assertNotNull(result);
+ assertEquals("", result);
+ verify(rangerAdminMetricsWrapper, times(1)).getRangerMetricsInPrometheusFormat();
+ }
+
+ @Test
+ public void testGetMetricsJson_Success() throws Exception {
+ Map<String, Map<String, Object>> expectedJsonMetrics = new HashMap<>();
+ Map<String, Object> jvmMetrics = new HashMap<>();
+ jvmMetrics.put("heapUsed", 40424768L);
+ jvmMetrics.put("heapMax", 7635730432L);
+ expectedJsonMetrics.put("jvm", jvmMetrics);
+
+ Map<String, Object> httpMetrics = new HashMap<>();
+ httpMetrics.put("requestCount", 1000);
+ httpMetrics.put("responseTime", 250.5);
+ expectedJsonMetrics.put("http", httpMetrics);
+
+ when(rangerAdminMetricsWrapper.getRangerMetrics()).thenReturn(expectedJsonMetrics);
+
+ Map<String, Map<String, Object>> result = metricsREST.getMetricsJson();
+
+ assertNotNull(result);
+ assertEquals(expectedJsonMetrics, result);
+ assertEquals(2, result.size());
+ assertTrue(result.containsKey("jvm"));
+ assertTrue(result.containsKey("http"));
+
+ Map<String, Object> jvmResult = result.get("jvm");
+ assertEquals(40424768L, jvmResult.get("heapUsed"));
+ assertEquals(7635730432L, jvmResult.get("heapMax"));
+
+ Map<String, Object> httpResult = result.get("http");
+ assertEquals(1000, httpResult.get("requestCount"));
+ assertEquals(250.5, httpResult.get("responseTime"));
+
+ verify(rangerAdminMetricsWrapper, times(1)).getRangerMetrics();
+ }
+
+ @Test
+ public void testGetMetricsJson_Exception() throws Exception {
+ when(rangerAdminMetricsWrapper.getRangerMetrics()).thenThrow(new RuntimeException("Metrics exception"));
+
+ Map<String, Map<String, Object>> result = metricsREST.getMetricsJson();
+
+ assertNull(result);
+ verify(rangerAdminMetricsWrapper, times(1)).getRangerMetrics();
+ }
+
+ @Test
+ public void testGetMetricsJson_EmptyResult() throws Exception {
+ Map<String, Map<String, Object>> emptyMetrics = new HashMap<>();
+ when(rangerAdminMetricsWrapper.getRangerMetrics()).thenReturn(emptyMetrics);
+
+ Map<String, Map<String, Object>> result = metricsREST.getMetricsJson();
+
+ assertNotNull(result);
+ assertTrue(result.isEmpty());
+ verify(rangerAdminMetricsWrapper, times(1)).getRangerMetrics();
}
private Map<String, Object> getRangerMetricsValues() {
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java
index be33dc11d..4a96a26fa 100644
--- a/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java
@@ -17,17 +17,24 @@
package org.apache.ranger.rest;
+import org.apache.ranger.admin.client.datatype.RESTResponse;
import org.apache.ranger.biz.SecurityZoneDBStore;
import org.apache.ranger.common.ContextUtil;
import org.apache.ranger.common.RESTErrorUtil;
import org.apache.ranger.common.RangerSearchUtil;
import org.apache.ranger.common.UserSessionBase;
+import org.apache.ranger.plugin.model.RangerPluginInfo;
import org.apache.ranger.plugin.model.RangerPolicy;
import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess;
import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition;
import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource;
+import org.apache.ranger.plugin.model.RangerRole;
+import org.apache.ranger.plugin.model.RangerSecurityZone;
import org.apache.ranger.plugin.model.RangerSecurityZoneHeaderInfo;
+import org.apache.ranger.plugin.model.RangerSecurityZoneV2;
+import org.apache.ranger.plugin.model.RangerSecurityZoneV2.RangerSecurityZoneChangeRequest;
+import org.apache.ranger.plugin.model.RangerSecurityZoneV2.RangerSecurityZoneResource;
import org.apache.ranger.plugin.model.RangerService;
import org.apache.ranger.plugin.model.RangerServiceDef;
import org.apache.ranger.plugin.model.RangerServiceDef.RangerAccessTypeDef;
@@ -37,56 +44,72 @@
import org.apache.ranger.plugin.model.RangerServiceDef.RangerResourceDef;
import org.apache.ranger.plugin.model.RangerServiceDef.RangerServiceConfigDef;
import org.apache.ranger.plugin.model.RangerServiceHeaderInfo;
+import org.apache.ranger.plugin.model.RangerServiceTags;
+import org.apache.ranger.plugin.store.PList;
+import org.apache.ranger.plugin.util.GrantRevokeRoleRequest;
+import org.apache.ranger.plugin.util.RangerPurgeResult;
+import org.apache.ranger.plugin.util.ServiceTags;
import org.apache.ranger.security.context.RangerContextHolder;
import org.apache.ranger.security.context.RangerSecurityContext;
import org.apache.ranger.service.RangerPolicyService;
+import org.apache.ranger.view.RangerPluginInfoList;
import org.apache.ranger.view.RangerPolicyList;
+import org.apache.ranger.view.RangerRoleList;
+import org.apache.ranger.view.RangerSecurityZoneList;
import org.apache.ranger.view.RangerServiceDefList;
import org.apache.ranger.view.RangerServiceList;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.FixMethodOrder;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.WebApplicationException;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-@RunWith(MockitoJUnitRunner.class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+/**
+* @generated by Cursor
+* @description <Unit Test for TestPublicAPIsv2 class>
+*/
+@ExtendWith(MockitoExtension.class)
+@TestMethodOrder(MethodOrderer.MethodName.class)
public class TestPublicAPIsv2 {
private static final Long Id = 8L;
private static final Long Id2 = 10L;
- @Rule
- public ExpectedException thrown = ExpectedException.none();
@InjectMocks
- PublicAPIsv2 publicAPIsv2 = new PublicAPIsv2();
+ PublicAPIsv2 publicAPIsv2 = new PublicAPIsv2();
@Mock
- ServiceREST serviceREST;
+ ServiceREST serviceREST;
@Mock
- RangerSearchUtil searchUtil;
+ SecurityZoneREST securityZoneRest;
+ @Mock
+ RangerSearchUtil searchUtil;
@Mock
RangerPolicyService policyService;
@Mock
- RESTErrorUtil restErrorUtil;
+ RESTErrorUtil restErrorUtil;
@Mock
SecurityZoneDBStore securityZoneStore;
+ @Mock
+ TagREST tagREST;
+ @Mock
+ RoleREST roleREST;
- @Before
- public void setup() {
+ @BeforeEach
+ public void setup() throws Exception {
RangerSecurityContext context = new RangerSecurityContext();
context.setUserSession(new UserSessionBase());
RangerContextHolder.setSecurityContext(context);
@@ -95,85 +118,85 @@ public void setup() {
}
@Test
- public void test1getServiceDef() {
+ public void test1getServiceDef() throws Exception {
RangerServiceDef rangerServiceDef = rangerServiceDef();
Mockito.when(serviceREST.getServiceDef(rangerServiceDef.getId())).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = publicAPIsv2.getServiceDef(Id);
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
Mockito.verify(serviceREST).getServiceDef(Id);
}
@Test
- public void test2getServiceDefByName() {
+ public void test2getServiceDefByName() throws Exception {
RangerServiceDef rangerServiceDef = rangerServiceDef();
String name = rangerServiceDef.getName();
Mockito.when(serviceREST.getServiceDefByName(name)).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = publicAPIsv2.getServiceDefByName(name);
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
Mockito.verify(serviceREST).getServiceDefByName(name);
}
@Test
- public void test3searchServiceDefs() {
+ public void test3searchServiceDefs() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
- List<RangerServiceDef> serviceDefsList = new ArrayList<>();
+ List<RangerServiceDef> serviceDefsList = new ArrayList<RangerServiceDef>();
RangerServiceDef serviceDef = rangerServiceDef();
serviceDefsList.add(serviceDef);
RangerServiceDefList serviceDefList = new RangerServiceDefList(serviceDefsList);
Mockito.when(serviceREST.getServiceDefs(request)).thenReturn(serviceDefList);
List<RangerServiceDef> dbRangerServiceDefList = publicAPIsv2.searchServiceDefs(request);
- Assert.assertNotNull(dbRangerServiceDefList);
- Assert.assertEquals(dbRangerServiceDefList.size(), serviceDefsList.size());
+ Assertions.assertNotNull(dbRangerServiceDefList);
+ Assertions.assertEquals(dbRangerServiceDefList.size(), serviceDefsList.size());
Mockito.verify(serviceREST).getServiceDefs(request);
}
@Test
- public void test4createServiceDef() {
+ public void test4createServiceDef() throws Exception {
RangerServiceDef rangerServiceDef = rangerServiceDef();
Mockito.when(serviceREST.createServiceDef(rangerServiceDef)).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = publicAPIsv2.createServiceDef(rangerServiceDef);
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
Mockito.verify(serviceREST).createServiceDef(rangerServiceDef);
}
@Test
- public void test5updateServiceDef() {
+ public void test5updateServiceDef() throws Exception {
RangerServiceDef rangerServiceDef = rangerServiceDef();
Mockito.when(serviceREST.updateServiceDef(rangerServiceDef, rangerServiceDef.getId())).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = publicAPIsv2.updateServiceDef(rangerServiceDef, Id);
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
Mockito.verify(serviceREST).updateServiceDef(rangerServiceDef, rangerServiceDef.getId());
}
@Test
- public void test6updateServiceDefByName() {
+ public void test6updateServiceDefByName() throws Exception {
RangerServiceDef rangerServiceDef = rangerServiceDef();
String name = rangerServiceDef.getName();
Mockito.when(serviceREST.getServiceDefByName(name)).thenReturn(rangerServiceDef);
Mockito.when(serviceREST.updateServiceDef(rangerServiceDef, rangerServiceDef.getId())).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = publicAPIsv2.updateServiceDefByName(rangerServiceDef, name);
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
Mockito.verify(serviceREST).updateServiceDef(rangerServiceDef, dbRangerServiceDef.getId());
Mockito.verify(serviceREST).getServiceDefByName(name);
}
@Test
- public void test7deleteServiceDef() {
+ public void test7deleteServiceDef() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
Mockito.doNothing().when(serviceREST).deleteServiceDef(Id, request);
publicAPIsv2.deleteServiceDef(Id, request);
@@ -181,7 +204,7 @@ public void test7deleteServiceDef() {
}
@Test
- public void test8deleteServiceDefByName() {
+ public void test8deleteServiceDefByName() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
RangerServiceDef rangerServiceDef = rangerServiceDef();
String name = rangerServiceDef.getName();
@@ -193,96 +216,94 @@ public void test8deleteServiceDefByName() {
}
@Test
- public void test9getService() {
+ public void test9getService() throws Exception {
RangerService rangerService = rangerService();
Mockito.when(serviceREST.getService(rangerService.getId())).thenReturn(rangerService);
RangerService dbRangerService = publicAPIsv2.getService(Id);
- Assert.assertNotNull(dbRangerService);
- Assert.assertEquals(dbRangerService, rangerService);
- Assert.assertEquals(dbRangerService.getId(), rangerService.getId());
- Assert.assertEquals(dbRangerService.getName(), rangerService.getName());
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertEquals(dbRangerService, rangerService);
+ Assertions.assertEquals(dbRangerService.getId(), rangerService.getId());
+ Assertions.assertEquals(dbRangerService.getName(), rangerService.getName());
Mockito.verify(serviceREST).getService(Id);
}
@Test
- public void test10getServiceByName() {
+ public void test10getServiceByName() throws Exception {
RangerService rangerService = rangerService();
String name = rangerService.getName();
Mockito.when(serviceREST.getServiceByName(name)).thenReturn(rangerService);
RangerService dbRangerService = publicAPIsv2.getServiceByName(name);
- Assert.assertNotNull(dbRangerService);
- Assert.assertEquals(dbRangerService, rangerService);
- Assert.assertEquals(dbRangerService.getId(), rangerService.getId());
- Assert.assertEquals(dbRangerService.getName(), rangerService.getName());
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertEquals(dbRangerService, rangerService);
+ Assertions.assertEquals(dbRangerService.getId(), rangerService.getId());
+ Assertions.assertEquals(dbRangerService.getName(), rangerService.getName());
Mockito.verify(serviceREST).getServiceByName(name);
}
@Test
- public void test11searchServices() {
+ public void test11searchServices() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
- List<RangerService> servicesList = new ArrayList<>();
+ List<RangerService> servicesList = new ArrayList<RangerService>();
RangerService service = rangerService();
servicesList.add(service);
RangerServiceList serviceList = new RangerServiceList(servicesList);
Mockito.when(serviceREST.getServices(request)).thenReturn(serviceList);
List<RangerService> dbRangerServiceList = publicAPIsv2.searchServices(request);
- Assert.assertNotNull(dbRangerServiceList);
- Assert.assertEquals(dbRangerServiceList.size(), servicesList.size());
+ Assertions.assertNotNull(dbRangerServiceList);
+ Assertions.assertEquals(dbRangerServiceList.size(), servicesList.size());
Mockito.verify(serviceREST).getServices(request);
}
@Test
- public void test12createService() {
+ public void test12createService() throws Exception {
RangerService rangerService = rangerService();
Mockito.when(serviceREST.createService(rangerService)).thenReturn(rangerService);
RangerService dbRangerService = publicAPIsv2.createService(rangerService);
- Assert.assertNotNull(dbRangerService);
- Assert.assertEquals(dbRangerService, rangerService);
- Assert.assertEquals(dbRangerService.getId(), rangerService.getId());
- Assert.assertEquals(dbRangerService.getName(), rangerService.getName());
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertEquals(dbRangerService, rangerService);
+ Assertions.assertEquals(dbRangerService.getId(), rangerService.getId());
+ Assertions.assertEquals(dbRangerService.getName(), rangerService.getName());
Mockito.verify(serviceREST).createService(rangerService);
}
@Test
- public void test13updateService() {
+ public void test13updateService() throws Exception {
RangerService rangerService = rangerService();
HttpServletRequest request = null;
Mockito.when(serviceREST.updateService(rangerService, request)).thenReturn(rangerService);
RangerService dbRangerService = publicAPIsv2.updateService(rangerService, Id, request);
- Assert.assertNotNull(dbRangerService);
- Assert.assertEquals(dbRangerService, rangerService);
- Assert.assertEquals(dbRangerService.getId(),
- rangerService.getId());
- Assert.assertEquals(dbRangerService.getName(),
- rangerService.getName());
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertEquals(dbRangerService, rangerService);
+ Assertions.assertEquals(dbRangerService.getId(), rangerService.getId());
+ Assertions.assertEquals(dbRangerService.getName(), rangerService.getName());
Mockito.verify(serviceREST).updateService(rangerService, request);
}
@Test
- public void test14updateServiceByName() {
+ public void test14updateServiceByName() throws Exception {
RangerService rangerService = rangerService();
HttpServletRequest request = null;
String name = rangerService.getName();
Mockito.when(serviceREST.getServiceByName(name)).thenReturn(rangerService);
Mockito.when(serviceREST.updateService(rangerService, request)).thenReturn(rangerService);
RangerService dbRangerService = publicAPIsv2.updateServiceByName(rangerService, name, request);
- Assert.assertNotNull(dbRangerService);
- Assert.assertEquals(dbRangerService, rangerService);
- Assert.assertEquals(dbRangerService.getId(), rangerService.getId());
- Assert.assertEquals(dbRangerService.getName(), rangerService.getName());
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertEquals(dbRangerService, rangerService);
+ Assertions.assertEquals(dbRangerService.getId(), rangerService.getId());
+ Assertions.assertEquals(dbRangerService.getName(), rangerService.getName());
Mockito.verify(serviceREST).updateService(rangerService, request);
Mockito.verify(serviceREST).getServiceByName(name);
}
@Test
- public void test15deleteService() {
+ public void test15deleteService() throws Exception {
Mockito.doNothing().when(serviceREST).deleteService(Id);
publicAPIsv2.deleteService(Id);
Mockito.verify(serviceREST).deleteService(Id);
}
@Test
- public void test16deleteServiceByName() {
+ public void test16deleteServiceByName() throws Exception {
RangerService rangerService = rangerService();
String name = rangerService.getName();
Mockito.when(serviceREST.getServiceByName(name)).thenReturn(rangerService);
@@ -293,19 +314,19 @@ public void test16deleteServiceByName() {
}
@Test
- public void test17getPolicy() {
+ public void test17getPolicy() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
Mockito.when(serviceREST.getPolicy(rangerPolicy.getId())).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = publicAPIsv2.getPolicy(Id);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
Mockito.verify(serviceREST).getPolicy(Id);
}
@Test
- public void test18getPolicyByName() {
+ public void test18getPolicyByName() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
RangerPolicy rangerPolicy = rangerPolicy();
RangerService rangerService = rangerService();
@@ -314,19 +335,17 @@ public void test18getPolicyByName() {
String zoneName = "zone-1";
Mockito.when(serviceREST.getPolicyByName(Mockito.anyString(), Mockito.anyString(), Mockito.anyString())).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = publicAPIsv2.getPolicyByName(serviceName, policyName, zoneName, request);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(),
- rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(),
- rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
Mockito.verify(serviceREST).getPolicyByName(Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
}
@Test
- public void test19searchPolicies() {
+ public void test19searchPolicies() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
- List<RangerPolicy> policiesList = new ArrayList<>();
+ List<RangerPolicy> policiesList = new ArrayList<RangerPolicy>();
RangerService service = rangerService();
String serviceName = service.getName();
RangerPolicy rangerPolicy = rangerPolicy();
@@ -334,51 +353,51 @@ public void test19searchPolicies() {
RangerPolicyList policyList = new RangerPolicyList(policiesList);
Mockito.when(serviceREST.getServicePoliciesByName(serviceName, request)).thenReturn(policyList);
List<RangerPolicy> dbRangerPolicyList = publicAPIsv2.searchPolicies(serviceName, request);
- Assert.assertNotNull(dbRangerPolicyList);
- Assert.assertEquals(dbRangerPolicyList.size(), policiesList.size());
+ Assertions.assertNotNull(dbRangerPolicyList);
+ Assertions.assertEquals(dbRangerPolicyList.size(), policiesList.size());
Mockito.verify(serviceREST).getServicePoliciesByName(serviceName, request);
}
@Test
- public void test20createPolicy() {
+ public void test20createPolicy() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
RangerPolicy rangerPolicy = rangerPolicy();
Mockito.when(serviceREST.createPolicy(rangerPolicy, request)).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = publicAPIsv2.createPolicy(rangerPolicy, request);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
Mockito.verify(serviceREST).createPolicy(rangerPolicy, request);
}
@Test
- public void test21applyPolicy() {
+ public void test21applyPolicy() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
RangerPolicy rangerPolicy = rangerPolicy();
Mockito.when(serviceREST.applyPolicy(rangerPolicy, request)).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = publicAPIsv2.applyPolicy(rangerPolicy, request);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
Mockito.verify(serviceREST).applyPolicy(rangerPolicy, request);
}
@Test
- public void test22updatePolicy() {
+ public void test22updatePolicy() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
Mockito.when(serviceREST.updatePolicy(rangerPolicy, Id)).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = publicAPIsv2.updatePolicy(rangerPolicy, Id);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
Mockito.verify(serviceREST).updatePolicy(rangerPolicy, Id);
}
@Test
- public void test23updatePolicyByName() {
+ public void test23updatePolicyByName() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
RangerPolicy rangerPolicy = rangerPolicy();
String policyName = rangerPolicy.getName();
@@ -388,23 +407,23 @@ public void test23updatePolicyByName() {
Mockito.when(serviceREST.getPolicyByName(Mockito.anyString(), Mockito.anyString(), Mockito.anyString())).thenReturn(rangerPolicy);
Mockito.when(serviceREST.updatePolicy(rangerPolicy, rangerPolicy.getId())).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = publicAPIsv2.updatePolicyByName(rangerPolicy, serviceName, policyName, zoneName, request);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
Mockito.verify(serviceREST).updatePolicy(rangerPolicy, rangerPolicy.getId());
Mockito.verify(serviceREST).getPolicyByName(Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
}
@Test
- public void test24deletePolicy() {
+ public void test24deletePolicy() throws Exception {
Mockito.doNothing().when(serviceREST).deletePolicy(Id);
publicAPIsv2.deletePolicy(Id);
Mockito.verify(serviceREST).deletePolicy(Id);
}
@Test
- public void test25deletePolicyByName() {
+ public void test25deletePolicyByName() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
RangerPolicy rangerPolicy = rangerPolicy();
String policyName = rangerPolicy.getName();
@@ -419,10 +438,10 @@ public void test25deletePolicyByName() {
}
@Test
- public void test26getPolicies() {
+ public void test26getPolicies() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
RangerPolicyList policyList = Mockito.mock(RangerPolicyList.class);
- List<RangerPolicy> rangerPolicies = new ArrayList<>();
+ List<RangerPolicy> rangerPolicies = new ArrayList<RangerPolicy>();
RangerPolicy rangerpolicy1 = rangerPolicy();
RangerPolicy rangerpolicy2 = rangerPolicy1();
rangerPolicies.add(rangerpolicy1);
@@ -430,13 +449,13 @@ public void test26getPolicies() {
Mockito.when(serviceREST.getPolicies(request)).thenReturn(policyList);
Mockito.when(policyList.getPolicies()).thenReturn(rangerPolicies);
List<RangerPolicy> dbRangerPolicies = publicAPIsv2.getPolicies(request);
- Assert.assertNotNull(dbRangerPolicies);
- Assert.assertEquals(dbRangerPolicies.size(), rangerPolicies.size());
+ Assertions.assertNotNull(dbRangerPolicies);
+ Assertions.assertEquals(dbRangerPolicies.size(), rangerPolicies.size());
Mockito.verify(serviceREST).getPolicies(request);
}
@Test
- public void testGetAllZoneNames() {
+ public void testGetAllZoneNames() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
List<RangerSecurityZoneHeaderInfo> zoneHeaderInfoList = new ArrayList<>();
@@ -447,18 +466,18 @@ public void testGetAllZoneNames() {
List<RangerSecurityZoneHeaderInfo> returnedZoneHeaderInfoList = publicAPIsv2.getSecurityZoneHeaderInfoList(request);
- Assert.assertEquals(returnedZoneHeaderInfoList.size(), zoneHeaderInfoList.size());
+ Assertions.assertEquals(returnedZoneHeaderInfoList.size(), zoneHeaderInfoList.size());
Mockito.verify(securityZoneStore, Mockito.times(1)).getSecurityZoneHeaderInfoList(request);
}
@Test
- public void testGetServiceNamesForZone() {
+ public void testGetServiceNamesForZone() throws Exception {
Long zoneId1 = 2L;
Long zoneId2 = 3L;
Long nonExistingZondId = 101L;
- List<RangerServiceHeaderInfo> rangerServiceList1 = new ArrayList<>();
- List<RangerServiceHeaderInfo> rangerServiceList2 = new ArrayList<>();
+ List<RangerServiceHeaderInfo> rangerServiceList1 = new ArrayList<RangerServiceHeaderInfo>();
+ List<RangerServiceHeaderInfo> rangerServiceList2 = new ArrayList<RangerServiceHeaderInfo>();
rangerServiceList1.add(new RangerServiceHeaderInfo(1L, "hdfs_1", false));
rangerServiceList1.add(new RangerServiceHeaderInfo(2L, "hive_1", false));
@@ -478,55 +497,55 @@ public void testGetServiceNamesForZone() {
List<RangerServiceHeaderInfo> returnedServicesNull = publicAPIsv2.getServiceHeaderInfoListByZoneId(null, request);
Mockito.verify(securityZoneStore, Mockito.times(1)).getServiceHeaderInfoListByZoneId(null, request);
- Assert.assertEquals(0, returnedServicesNull.size());
+ Assertions.assertEquals(returnedServicesNull.size(), 0);
// Non existing zoneId
List<RangerServiceHeaderInfo> returnedServicesNonExisting = publicAPIsv2.getServiceHeaderInfoListByZoneId(nonExistingZondId, request);
Mockito.verify(securityZoneStore, Mockito.times(1)).getServiceHeaderInfoListByZoneId(null, request);
- Assert.assertEquals(0, returnedServicesNonExisting.size());
+ Assertions.assertEquals(returnedServicesNonExisting.size(), 0);
// zoneId1
List<RangerServiceHeaderInfo> returnedServicesZone1 = publicAPIsv2.getServiceHeaderInfoListByZoneId(zoneId1, request);
Mockito.verify(securityZoneStore, Mockito.times(1)).getServiceHeaderInfoListByZoneId(zoneId1, request);
- Assert.assertEquals(returnedServicesZone1.size(), rangerServiceList1.size());
+ Assertions.assertEquals(returnedServicesZone1.size(), rangerServiceList1.size());
// zoneId2
List<RangerServiceHeaderInfo> returnedServicesZone2 = publicAPIsv2.getServiceHeaderInfoListByZoneId(zoneId2, request);
Mockito.verify(securityZoneStore, Mockito.times(1)).getServiceHeaderInfoListByZoneId(zoneId2, request);
- Assert.assertEquals(returnedServicesZone2.size(), rangerServiceList2.size());
+ Assertions.assertEquals(returnedServicesZone2.size(), rangerServiceList2.size());
}
@Test
- public void testGetPolicyByGUIDAndServiceNameAndZoneName() {
+ public void testGetPolicyByGUIDAndServiceNameAndZoneName() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
RangerService rangerService = rangerService();
String serviceName = rangerService.getName();
Mockito.when(serviceREST.getPolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), serviceName, "zone-1")).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = publicAPIsv2.getPolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), serviceName, "zone-1");
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
Mockito.verify(serviceREST).getPolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), serviceName, "zone-1");
}
@Test
- public void testGetPolicyByGUID() {
+ public void testGetPolicyByGUID() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
Mockito.when(serviceREST.getPolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), null, null)).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = publicAPIsv2.getPolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), null, null);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
Mockito.verify(serviceREST).getPolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), null, null);
}
@Test
- public void testDeletePolicyByGUIDAndServiceNameAndZoneName() {
+ public void testDeletePolicyByGUIDAndServiceNameAndZoneName() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
RangerService rangerService = rangerService();
String serviceName = rangerService.getName();
@@ -537,7 +556,7 @@ public void testDeletePolicyByGUIDAndServiceNameAndZoneName() {
}
@Test
- public void testDeletePolicyByGUID() {
+ public void testDeletePolicyByGUID() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
Mockito.doNothing().when(serviceREST).deletePolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), null, null);
publicAPIsv2.deletePolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), null, null);
@@ -545,12 +564,12 @@ public void testDeletePolicyByGUID() {
}
private RangerServiceDef rangerServiceDef() {
- List<RangerServiceConfigDef> configs = new ArrayList<>();
- List<RangerResourceDef> resources = new ArrayList<>();
- List<RangerAccessTypeDef> accessTypes = new ArrayList<>();
- List<RangerPolicyConditionDef> policyConditions = new ArrayList<>();
- List<RangerContextEnricherDef> contextEnrichers = new ArrayList<>();
- List<RangerEnumDef> enums = new ArrayList<>();
+ List<RangerServiceConfigDef> configs = new ArrayList<RangerServiceConfigDef>();
+ List<RangerResourceDef> resources = new ArrayList<RangerResourceDef>();
+ List<RangerAccessTypeDef> accessTypes = new ArrayList<RangerAccessTypeDef>();
+ List<RangerPolicyConditionDef> policyConditions = new ArrayList<RangerPolicyConditionDef>();
+ List<RangerContextEnricherDef> contextEnrichers = new ArrayList<RangerContextEnricherDef>();
+ List<RangerEnumDef> enums = new ArrayList<RangerEnumDef>();
RangerServiceDef rangerServiceDef = new RangerServiceDef();
rangerServiceDef.setId(Id);
@@ -572,7 +591,7 @@ private RangerServiceDef rangerServiceDef() {
}
private RangerService rangerService() {
- Map<String, String> configs = new HashMap<>();
+ Map<String, String> configs = new HashMap<String, String>();
configs.put("username", "servicemgr");
configs.put("password", "servicemgr");
configs.put("namenode", "servicemgr");
@@ -602,11 +621,11 @@ private RangerService rangerService() {
}
private RangerPolicy rangerPolicy() {
- List<RangerPolicyItemAccess> accesses = new ArrayList<>();
- List<String> users = new ArrayList<>();
- List<String> groups = new ArrayList<>();
- List<RangerPolicyItemCondition> conditions = new ArrayList<>();
- List<RangerPolicyItem> policyItems = new ArrayList<>();
+ List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();
+ List<String> users = new ArrayList<String>();
+ List<String> groups = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>();
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>();
RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
rangerPolicyItem.setAccesses(accesses);
rangerPolicyItem.setConditions(conditions);
@@ -616,7 +635,7 @@ private RangerPolicy rangerPolicy() {
policyItems.add(rangerPolicyItem);
- Map<String, RangerPolicyResource> policyResource = new HashMap<>();
+ Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>();
RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
rangerPolicyResource.setIsExcludes(true);
rangerPolicyResource.setIsRecursive(true);
@@ -632,7 +651,7 @@ private RangerPolicy rangerPolicy() {
policy.setName("HDFS_1-1-20150316062453");
policy.setUpdatedBy("Admin");
policy.setUpdateTime(new Date());
- policy.setService("HDFS_1-1-20150316062453");
+ policy.setService("HDFS_1");
policy.setIsAuditEnabled(true);
policy.setPolicyItems(policyItems);
policy.setResources(policyResource);
@@ -642,11 +661,11 @@ private RangerPolicy rangerPolicy() {
}
private RangerPolicy rangerPolicy1() {
- List<RangerPolicyItemAccess> accesses = new ArrayList<>();
- List<String> users = new ArrayList<>();
- List<String> groups = new ArrayList<>();
- List<RangerPolicyItemCondition> conditions = new ArrayList<>();
- List<RangerPolicyItem> policyItems = new ArrayList<>();
+ List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();
+ List<String> users = new ArrayList<String>();
+ List<String> groups = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>();
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>();
RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
rangerPolicyItem.setAccesses(accesses);
rangerPolicyItem.setConditions(conditions);
@@ -656,7 +675,7 @@ private RangerPolicy rangerPolicy1() {
policyItems.add(rangerPolicyItem);
- Map<String, RangerPolicyResource> policyResource = new HashMap<>();
+ Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>();
RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
rangerPolicyResource.setIsExcludes(true);
rangerPolicyResource.setIsRecursive(true);
@@ -680,4 +699,902 @@ private RangerPolicy rangerPolicy1() {
return policy;
}
+
+ @Test
+ public void test27createSecurityZone() throws Exception {
+ RangerSecurityZone securityZone = new RangerSecurityZone();
+ securityZone.setId(Id);
+ securityZone.setName("test-zone");
+ securityZone.setDescription("Test security zone");
+
+ Mockito.when(securityZoneRest.createSecurityZone(securityZone)).thenReturn(securityZone);
+ RangerSecurityZone result = publicAPIsv2.createSecurityZone(securityZone);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), securityZone.getId());
+ Assertions.assertEquals(result.getName(), securityZone.getName());
+
+ Mockito.verify(securityZoneRest).createSecurityZone(securityZone);
+ }
+
+ @Test
+ public void test28updateSecurityZone() throws Exception {
+ RangerSecurityZone securityZone = new RangerSecurityZone();
+ securityZone.setId(Id);
+ securityZone.setName("test-zone-updated");
+ securityZone.setDescription("Updated test security zone");
+
+ Mockito.when(securityZoneRest.updateSecurityZone(Id, securityZone)).thenReturn(securityZone);
+ RangerSecurityZone result = publicAPIsv2.updateSecurityZone(Id, securityZone);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), securityZone.getId());
+ Assertions.assertEquals(result.getName(), securityZone.getName());
+
+ Mockito.verify(securityZoneRest).updateSecurityZone(Id, securityZone);
+ }
+
+ @Test
+ public void test29deleteSecurityZoneByName() throws Exception {
+ String zoneName = "test-zone";
+ Mockito.doNothing().when(securityZoneRest).deleteSecurityZone(zoneName);
+
+ publicAPIsv2.deleteSecurityZone(zoneName);
+
+ Mockito.verify(securityZoneRest).deleteSecurityZone(zoneName);
+ }
+
+ @Test
+ public void test30deleteSecurityZoneById() throws Exception {
+ Mockito.doNothing().when(securityZoneRest).deleteSecurityZone(Id);
+
+ publicAPIsv2.deleteSecurityZone(Id);
+
+ Mockito.verify(securityZoneRest).deleteSecurityZone(Id);
+ }
+
+ @Test
+ public void test31getSecurityZoneByName() throws Exception {
+ String zoneName = "test-zone";
+ RangerSecurityZone securityZone = new RangerSecurityZone();
+ securityZone.setId(Id);
+ securityZone.setName(zoneName);
+
+ Mockito.when(securityZoneRest.getSecurityZone(zoneName)).thenReturn(securityZone);
+ RangerSecurityZone result = publicAPIsv2.getSecurityZone(zoneName);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getName(), zoneName);
+
+ Mockito.verify(securityZoneRest).getSecurityZone(zoneName);
+ }
+
+ @Test
+ public void test32updateServiceWithIdMismatch() throws Exception {
+ RangerService service = rangerService();
+ service.setId(Id2); // Different ID than path parameter
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ publicAPIsv2.updateService(service, Id, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test33updateServiceDefWithMisMatchName() throws Exception {
+ RangerServiceDef serviceDef = rangerServiceDef();
+ String name = "non-existent-service-def";
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ publicAPIsv2.updateServiceDefByName(serviceDef, name);
+ });
+
+ Mockito.verify(serviceREST, Mockito.never()).getServiceDefByName(name);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test34getPolicyByNameWithNullZone() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy policy = rangerPolicy();
+ String serviceName = "HDFS_1";
+ String policyName = "test-policy";
+
+ Mockito.when(serviceREST.getPolicyByName(serviceName, policyName, null)).thenReturn(policy);
+ RangerPolicy result = publicAPIsv2.getPolicyByName(serviceName, policyName, null, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), policy.getId());
+
+ Mockito.verify(serviceREST).getPolicyByName(serviceName, policyName, null);
+ }
+
+ @Test
+ public void test35updatePolicyByNameWithNullZone() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy policy = rangerPolicy();
+ String serviceName = "HDFS_1";
+ String policyName = "test-policy";
+
+ Mockito.when(serviceREST.getPolicyByName(serviceName, policyName, null)).thenReturn(policy);
+ Mockito.when(serviceREST.updatePolicy(policy, policy.getId())).thenReturn(policy);
+
+ RangerPolicy result = publicAPIsv2.updatePolicyByName(policy, serviceName, policyName, null, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), policy.getId());
+
+ Mockito.verify(serviceREST).getPolicyByName(serviceName, policyName, null);
+ Mockito.verify(serviceREST).updatePolicy(policy, policy.getId());
+ }
+
+ @Test
+ public void test36deletePolicyByNameWithNullZone() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy policy = rangerPolicy();
+ String serviceName = "HDFS_1";
+ String policyName = "test-policy";
+
+ Mockito.when(serviceREST.getPolicyByName(serviceName, policyName, null)).thenReturn(policy);
+ Mockito.doNothing().when(serviceREST).deletePolicy(policy.getId());
+
+ publicAPIsv2.deletePolicyByName(serviceName, policyName, null, request);
+
+ Mockito.verify(serviceREST).getPolicyByName(serviceName, policyName, null);
+ Mockito.verify(serviceREST).deletePolicy(policy.getId());
+ }
+
+ @Test
+ public void test37getPoliciesWithEmptyList() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicyList policyList = Mockito.mock(RangerPolicyList.class);
+ List<RangerPolicy> emptyPolicies = new ArrayList<>();
+
+ Mockito.when(serviceREST.getPolicies(request)).thenReturn(policyList);
+ Mockito.when(policyList.getPolicies()).thenReturn(emptyPolicies);
+
+ List<RangerPolicy> result = publicAPIsv2.getPolicies(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 0);
+
+ Mockito.verify(serviceREST).getPolicies(request);
+ }
+
+ @Test
+ public void test38getSecurityZoneHeaderInfoListEmpty() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerSecurityZoneHeaderInfo> emptyList = new ArrayList<>();
+
+ Mockito.when(securityZoneStore.getSecurityZoneHeaderInfoList(request)).thenReturn(emptyList);
+
+ List<RangerSecurityZoneHeaderInfo> result = publicAPIsv2.getSecurityZoneHeaderInfoList(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 0);
+
+ Mockito.verify(securityZoneStore).getSecurityZoneHeaderInfoList(request);
+ }
+
+ @Test
+ public void test39getServiceHeaderInfoListByZoneIdWithInvalidZone() throws Exception {
+ Long invalidZoneId = 999L;
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerServiceHeaderInfo> emptyList = new ArrayList<>();
+
+ Mockito.when(securityZoneStore.getServiceHeaderInfoListByZoneId(invalidZoneId, request)).thenReturn(emptyList);
+
+ List<RangerServiceHeaderInfo> result = publicAPIsv2.getServiceHeaderInfoListByZoneId(invalidZoneId, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 0);
+
+ Mockito.verify(securityZoneStore).getServiceHeaderInfoListByZoneId(invalidZoneId, request);
+ }
+
+ @Test
+ public void test40searchServicesWithEmptyResult() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerServiceList serviceList = new RangerServiceList();
+ serviceList.setServices(new ArrayList<>());
+
+ Mockito.when(serviceREST.getServices(request)).thenReturn(serviceList);
+
+ List<RangerService> result = publicAPIsv2.searchServices(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 0);
+
+ Mockito.verify(serviceREST).getServices(request);
+ }
+
+ @Test
+ public void test41searchServiceDefsWithEmptyResult() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerServiceDefList serviceDefList = new RangerServiceDefList();
+ serviceDefList.setServiceDefs(new ArrayList<>());
+
+ Mockito.when(serviceREST.getServiceDefs(request)).thenReturn(serviceDefList);
+
+ List<RangerServiceDef> result = publicAPIsv2.searchServiceDefs(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 0);
+
+ Mockito.verify(serviceREST).getServiceDefs(request);
+ }
+
+ @Test
+ public void test42searchPoliciesWithEmptyResult() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "HDFS_1";
+ RangerPolicyList policyList = new RangerPolicyList();
+ policyList.setPolicies(new ArrayList<>());
+
+ Mockito.when(serviceREST.getServicePoliciesByName(serviceName, request)).thenReturn(policyList);
+
+ List<RangerPolicy> result = publicAPIsv2.searchPolicies(serviceName, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 0);
+
+ Mockito.verify(serviceREST).getServicePoliciesByName(serviceName, request);
+ }
+
+ @Test
+ public void test43getServiceHeaders() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerServiceHeaderInfo> serviceHeaders = new ArrayList<>();
+ RangerServiceHeaderInfo headerInfo = new RangerServiceHeaderInfo();
+ headerInfo.setId(Id);
+ headerInfo.setName("HDFS_1");
+ headerInfo.setType("hdfs");
+ serviceHeaders.add(headerInfo);
+
+ Mockito.when(serviceREST.getServiceHeaders(request)).thenReturn(serviceHeaders);
+
+ List<RangerServiceHeaderInfo> result = publicAPIsv2.getServiceHeaders(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 1);
+ Assertions.assertEquals(result.get(0).getName(), "HDFS_1");
+
+ Mockito.verify(serviceREST).getServiceHeaders(request);
+ }
+
+ @Test
+ public void test44updatePolicyByNameNotFound() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy policy = rangerPolicy();
+ String serviceName = "HDFS_1";
+ String policyName = "non-existent-policy";
+ String zoneName = "zone-1";
+
+ Mockito.when(serviceREST.getPolicyByName(serviceName, policyName, zoneName)).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ publicAPIsv2.updatePolicyByName(policy, serviceName, policyName, zoneName, request);
+ });
+
+ Mockito.verify(serviceREST).getPolicyByName(serviceName, policyName, zoneName);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test45deletePolicyByNameNotFound() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "HDFS_1";
+ String policyName = "non-existent-policy";
+ String zoneName = "zone-1";
+
+ Mockito.when(serviceREST.getPolicyByName(serviceName, policyName, zoneName)).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ publicAPIsv2.deletePolicyByName(serviceName, policyName, zoneName, request);
+ });
+
+ Mockito.verify(serviceREST).getPolicyByName(serviceName, policyName, zoneName);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test46createSecurityZoneV2() throws Exception {
+ RangerSecurityZoneV2 securityZoneV2 = new RangerSecurityZoneV2();
+ securityZoneV2.setId(Id);
+ securityZoneV2.setName("test-zone-v2");
+ securityZoneV2.setDescription("Test security zone V2");
+
+ Mockito.when(securityZoneRest.createSecurityZone(securityZoneV2)).thenReturn(securityZoneV2);
+ RangerSecurityZoneV2 result = publicAPIsv2.createSecurityZone(securityZoneV2);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), securityZoneV2.getId());
+ Assertions.assertEquals(result.getName(), securityZoneV2.getName());
+
+ Mockito.verify(securityZoneRest).createSecurityZone(securityZoneV2);
+ }
+
+ @Test
+ public void test47updateSecurityZoneV2() throws Exception {
+ RangerSecurityZoneV2 securityZoneV2 = new RangerSecurityZoneV2();
+ securityZoneV2.setId(Id);
+ securityZoneV2.setName("test-zone-v2-updated");
+
+ Mockito.when(securityZoneRest.updateSecurityZone(Id, securityZoneV2)).thenReturn(securityZoneV2);
+ RangerSecurityZoneV2 result = publicAPIsv2.updateSecurityZone(Id, securityZoneV2);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), securityZoneV2.getId());
+
+ Mockito.verify(securityZoneRest).updateSecurityZone(Id, securityZoneV2);
+ }
+
+ @Test
+ public void test48updateSecurityZonePartial() throws Exception {
+ RangerSecurityZoneChangeRequest changeRequest = new RangerSecurityZoneChangeRequest();
+ Boolean expectedResult = true;
+
+ Mockito.when(securityZoneRest.updateSecurityZone(Id, changeRequest)).thenReturn(expectedResult);
+ Boolean result = publicAPIsv2.updateSecurityZone(Id, changeRequest);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result, expectedResult);
+
+ Mockito.verify(securityZoneRest).updateSecurityZone(Id, changeRequest);
+ }
+
+ @Test
+ public void test49getSecurityZoneV2ByName() throws Exception {
+ String zoneName = "test-zone-v2";
+ RangerSecurityZoneV2 securityZoneV2 = new RangerSecurityZoneV2();
+ securityZoneV2.setId(Id);
+ securityZoneV2.setName(zoneName);
+
+ Mockito.when(securityZoneRest.getSecurityZoneV2(zoneName)).thenReturn(securityZoneV2);
+ RangerSecurityZoneV2 result = publicAPIsv2.getSecurityZoneV2(zoneName);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getName(), zoneName);
+
+ Mockito.verify(securityZoneRest).getSecurityZoneV2(zoneName);
+ }
+
+ @Test
+ public void test50getSecurityZoneV2ById() throws Exception {
+ RangerSecurityZoneV2 securityZoneV2 = new RangerSecurityZoneV2();
+ securityZoneV2.setId(Id);
+ securityZoneV2.setName("test-zone-v2");
+
+ Mockito.when(securityZoneRest.getSecurityZoneV2(Id)).thenReturn(securityZoneV2);
+ RangerSecurityZoneV2 result = publicAPIsv2.getSecurityZoneV2(Id);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), Id);
+
+ Mockito.verify(securityZoneRest).getSecurityZoneV2(Id);
+ }
+
+ @Test
+ public void test51getResourcesByZoneId() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ PList<RangerSecurityZoneResource> resourceList = new PList<>();
+
+ Mockito.when(securityZoneRest.getResources(Id, serviceName, request)).thenReturn(resourceList);
+ PList<RangerSecurityZoneResource> result = publicAPIsv2.getResources(Id, serviceName, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result, resourceList);
+
+ Mockito.verify(securityZoneRest).getResources(Id, serviceName, request);
+ }
+
+ @Test
+ public void test52getResourcesByZoneName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String zoneName = "test-zone";
+ String serviceName = "hdfs_service";
+ PList<RangerSecurityZoneResource> resourceList = new PList<>();
+
+ Mockito.when(securityZoneRest.getResources(zoneName, serviceName, request)).thenReturn(resourceList);
+ PList<RangerSecurityZoneResource> result = publicAPIsv2.getResources(zoneName, serviceName, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result, resourceList);
+
+ Mockito.verify(securityZoneRest).getResources(zoneName, serviceName, request);
+ }
+
+ @Test
+ public void test53getAllZonesV2() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ PList<RangerSecurityZoneV2> zoneList = new PList<>();
+
+ Mockito.when(securityZoneRest.getAllZonesV2(request)).thenReturn(zoneList);
+ PList<RangerSecurityZoneV2> result = publicAPIsv2.getAllZonesV2(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result, zoneList);
+
+ Mockito.verify(securityZoneRest).getAllZonesV2(request);
+ }
+
+ @Test
+ public void test54importServiceTags() throws Exception {
+ String serviceName = "hdfs_service";
+ RangerServiceTags serviceTags = new RangerServiceTags();
+ serviceTags.setServiceName(serviceName);
+
+ Mockito.doNothing().when(tagREST).importServiceTags(Mockito.any(ServiceTags.class));
+
+ publicAPIsv2.importServiceTags(serviceName, serviceTags);
+
+ Mockito.verify(tagREST).importServiceTags(Mockito.any(ServiceTags.class));
+ }
+
+ @Test
+ public void test55getServiceTags() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ ServiceTags serviceTags = new ServiceTags();
+ serviceTags.setServiceName(serviceName);
+
+ Mockito.when(tagREST.getServiceTagsIfUpdated(serviceName, -1L, 0L, null, false, "", request)).thenReturn(serviceTags);
+
+ RangerServiceTags result = publicAPIsv2.getServiceTags(serviceName, request);
+
+ Assertions.assertNotNull(result);
+
+ Mockito.verify(tagREST).getServiceTagsIfUpdated(serviceName, -1L, 0L, null, false, "", request);
+ }
+
+ @Test
+ public void test56getPluginsInfo() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerPluginInfo> pluginInfoList = new ArrayList<>();
+ RangerPluginInfo pluginInfo = new RangerPluginInfo();
+ pluginInfo.setServiceName("hdfs_service");
+ pluginInfoList.add(pluginInfo);
+
+ Mockito.when(serviceREST.getPluginsInfo(request)).thenReturn(new RangerPluginInfoList(pluginInfoList));
+
+ List<RangerPluginInfo> result = publicAPIsv2.getPluginsInfo(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 1);
+
+ Mockito.verify(serviceREST).getPluginsInfo(request);
+ }
+
+ @Test
+ public void test57deletePolicyDeltas() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Integer olderThan = 10;
+
+ Mockito.doNothing().when(serviceREST).deletePolicyDeltas(olderThan, request);
+
+ publicAPIsv2.deletePolicyDeltas(olderThan, request);
+
+ Mockito.verify(serviceREST).deletePolicyDeltas(olderThan, request);
+ }
+
+ @Test
+ public void test58deleteTagDeltas() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Integer olderThan = 10;
+
+ Mockito.doNothing().when(tagREST).deleteTagDeltas(olderThan, request);
+
+ publicAPIsv2.deleteTagDeltas(olderThan, request);
+
+ Mockito.verify(tagREST).deleteTagDeltas(olderThan, request);
+ }
+
+ @Test
+ public void test59purgeEmptyPolicies() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+
+ Mockito.doNothing().when(serviceREST).purgeEmptyPolicies(serviceName, request);
+
+ publicAPIsv2.purgeEmptyPolicies(serviceName, request);
+
+ Mockito.verify(serviceREST).purgeEmptyPolicies(serviceName, request);
+ }
+
+ @Test
+ public void test60createRole() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ RangerRole role = new RangerRole();
+ role.setId(Id);
+ role.setName("test-role");
+ Boolean createNonExistUserGroup = false;
+
+ Mockito.when(roleREST.createRole(serviceName, role, createNonExistUserGroup)).thenReturn(role);
+
+ RangerRole result = publicAPIsv2.createRole(serviceName, role, createNonExistUserGroup, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), role.getId());
+ Assertions.assertEquals(result.getName(), role.getName());
+
+ Mockito.verify(roleREST).createRole(serviceName, role, createNonExistUserGroup);
+ }
+
+ @Test
+ public void test61updateRole() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerRole role = new RangerRole();
+ role.setId(Id);
+ role.setName("test-role-updated");
+ Boolean createNonExistUserGroup = false;
+
+ Mockito.when(roleREST.updateRole(Id, role, createNonExistUserGroup)).thenReturn(role);
+
+ RangerRole result = publicAPIsv2.updateRole(Id, role, createNonExistUserGroup, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), role.getId());
+
+ Mockito.verify(roleREST).updateRole(Id, role, createNonExistUserGroup);
+ }
+
+ @Test
+ public void test62deleteRoleByName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ String userName = "testuser";
+ String roleName = "test-role";
+
+ Mockito.doNothing().when(roleREST).deleteRole(serviceName, userName, roleName);
+
+ publicAPIsv2.deleteRole(serviceName, userName, roleName, request);
+
+ Mockito.verify(roleREST).deleteRole(serviceName, userName, roleName);
+ }
+
+ @Test
+ public void test63deleteRoleById() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.doNothing().when(roleREST).deleteRole(Id);
+
+ publicAPIsv2.deleteRole(Id, request);
+
+ Mockito.verify(roleREST).deleteRole(Id);
+ }
+
+ @Test
+ public void test64getRoleByName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ String userName = "testuser";
+ String roleName = "test-role";
+ RangerRole role = new RangerRole();
+ role.setId(Id);
+ role.setName(roleName);
+
+ Mockito.when(roleREST.getRole(serviceName, userName, roleName)).thenReturn(role);
+
+ RangerRole result = publicAPIsv2.getRole(serviceName, userName, roleName, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getName(), roleName);
+
+ Mockito.verify(roleREST).getRole(serviceName, userName, roleName);
+ }
+
+ @Test
+ public void test65getRoleById() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerRole role = new RangerRole();
+ role.setId(Id);
+ role.setName("test-role");
+
+ Mockito.when(roleREST.getRole(Id)).thenReturn(role);
+
+ RangerRole result = publicAPIsv2.getRole(Id, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), Id);
+
+ Mockito.verify(roleREST).getRole(Id);
+ }
+
+ @Test
+ public void test66getAllRoles() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerRole> roleList = new ArrayList<>();
+ RangerRole role = new RangerRole();
+ role.setId(Id);
+ role.setName("test-role");
+ roleList.add(role);
+
+ Mockito.when(roleREST.getAllRoles(request)).thenReturn(new RangerRoleList(roleList));
+
+ List<RangerRole> result = publicAPIsv2.getAllRoles(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 1);
+
+ Mockito.verify(roleREST).getAllRoles(request);
+ }
+
+ @Test
+ public void test67getAllRoleNames() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ String execUser = "testuser";
+ List<String> roleNames = new ArrayList<>();
+ roleNames.add("test-role");
+
+ Mockito.when(roleREST.getAllRoleNames(serviceName, execUser, request)).thenReturn(roleNames);
+
+ List<String> result = publicAPIsv2.getAllRoleNames(serviceName, execUser, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 1);
+ Assertions.assertEquals(result.get(0), "test-role");
+
+ Mockito.verify(roleREST).getAllRoleNames(serviceName, execUser, request);
+ }
+
+ @Test
+ public void test68getUserRoles() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String userName = "testuser";
+ List<String> userRoles = new ArrayList<>();
+ userRoles.add("test-role");
+
+ Mockito.when(roleREST.getUserRoles(userName, request)).thenReturn(userRoles);
+
+ List<String> result = publicAPIsv2.getUserRoles(userName, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 1);
+ Assertions.assertEquals(result.get(0), "test-role");
+
+ Mockito.verify(roleREST).getUserRoles(userName, request);
+ }
+
+ @Test
+ public void test69addUsersAndGroups() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<String> users = new ArrayList<>();
+ users.add("testuser");
+ List<String> groups = new ArrayList<>();
+ groups.add("testgroup");
+ Boolean isAdmin = true;
+ RangerRole role = new RangerRole();
+ role.setId(Id);
+
+ Mockito.when(roleREST.addUsersAndGroups(Id, users, groups, isAdmin)).thenReturn(role);
+
+ RangerRole result = publicAPIsv2.addUsersAndGroups(Id, users, groups, isAdmin, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), Id);
+
+ Mockito.verify(roleREST).addUsersAndGroups(Id, users, groups, isAdmin);
+ }
+
+ @Test
+ public void test70removeUsersAndGroups() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<String> users = new ArrayList<>();
+ users.add("testuser");
+ List<String> groups = new ArrayList<>();
+ groups.add("testgroup");
+ RangerRole role = new RangerRole();
+ role.setId(Id);
+
+ Mockito.when(roleREST.removeUsersAndGroups(Id, users, groups)).thenReturn(role);
+
+ RangerRole result = publicAPIsv2.removeUsersAndGroups(Id, users, groups, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), Id);
+
+ Mockito.verify(roleREST).removeUsersAndGroups(Id, users, groups);
+ }
+
+ @Test
+ public void test71removeAdminFromUsersAndGroups() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<String> users = new ArrayList<>();
+ users.add("testuser");
+ List<String> groups = new ArrayList<>();
+ groups.add("testgroup");
+ RangerRole role = new RangerRole();
+ role.setId(Id);
+
+ Mockito.when(roleREST.removeAdminFromUsersAndGroups(Id, users, groups)).thenReturn(role);
+
+ RangerRole result = publicAPIsv2.removeAdminFromUsersAndGroups(Id, users, groups, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), Id);
+
+ Mockito.verify(roleREST).removeAdminFromUsersAndGroups(Id, users, groups);
+ }
+
+ @Test
+ public void test72grantRole() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ GrantRevokeRoleRequest grantRoleRequest = new GrantRevokeRoleRequest();
+ RESTResponse response = new RESTResponse();
+
+ Mockito.when(roleREST.grantRole(serviceName, grantRoleRequest, request)).thenReturn(response);
+
+ RESTResponse result = publicAPIsv2.grantRole(serviceName, grantRoleRequest, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result, response);
+
+ Mockito.verify(roleREST).grantRole(serviceName, grantRoleRequest, request);
+ }
+
+ @Test
+ public void test73revokeRole() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ GrantRevokeRoleRequest revokeRoleRequest = new GrantRevokeRoleRequest();
+ RESTResponse response = new RESTResponse();
+
+ Mockito.when(roleREST.revokeRole(serviceName, revokeRoleRequest, request)).thenReturn(response);
+
+ RESTResponse result = publicAPIsv2.revokeRoleUsersAndRoles(serviceName, revokeRoleRequest, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result, response);
+
+ Mockito.verify(roleREST).revokeRole(serviceName, revokeRoleRequest, request);
+ }
+
+ @Test
+ public void test74purgeRecords() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String recordType = "policy";
+ Integer retentionDays = 180;
+ List<RangerPurgeResult> purgeResults = new ArrayList<>();
+ RangerPurgeResult purgeResult = new RangerPurgeResult();
+ purgeResults.add(purgeResult);
+
+ Mockito.when(serviceREST.purgeRecords(recordType, retentionDays, request)).thenReturn(purgeResults);
+
+ List<RangerPurgeResult> result = publicAPIsv2.purgeRecords(recordType, retentionDays, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 1);
+
+ Mockito.verify(serviceREST).purgeRecords(recordType, retentionDays, request);
+ }
+
+ @Test
+ public void test75getPoliciesForResource() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceDefName = "hdfs";
+ String serviceName = "hdfs_service";
+ List<RangerPolicy> policies = new ArrayList<>();
+ RangerPolicy policy = rangerPolicy();
+ policies.add(policy);
+
+ Mockito.when(serviceREST.getPoliciesForResource(serviceDefName, serviceName, request))
+ .thenReturn(policies);
+
+ List<RangerPolicy> result = publicAPIsv2.getPoliciesForResource(serviceDefName, serviceName, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 1);
+
+ Mockito.verify(serviceREST).getPoliciesForResource(serviceDefName, serviceName, request);
+ }
+
+ @Test
+ public void test76getSecurityZoneNamesForResource() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ Collection<String> zoneNames = new ArrayList<>();
+ zoneNames.add("zone1");
+ zoneNames.add("zone2");
+
+ Mockito.when(securityZoneRest.getZoneNamesForResource(serviceName, request)).thenReturn(zoneNames);
+
+ Collection<String> result = publicAPIsv2.getSecurityZoneNamesForResource(serviceName, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 2);
+
+ Mockito.verify(securityZoneRest).getZoneNamesForResource(serviceName, request);
+ }
+
+ @Test
+ public void test77getSecurityZoneHeaderInfoListByServiceId() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Long serviceId = 1L;
+ Boolean isTagService = false;
+ List<RangerSecurityZoneHeaderInfo> headerInfoList = new ArrayList<>();
+ RangerSecurityZoneHeaderInfo headerInfo = new RangerSecurityZoneHeaderInfo();
+ headerInfo.setId(Id);
+ headerInfo.setName("zone1");
+ headerInfoList.add(headerInfo);
+
+ Mockito.when(securityZoneRest.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request))
+ .thenReturn(headerInfoList);
+
+ List<RangerSecurityZoneHeaderInfo> result = publicAPIsv2.getSecurityZoneHeaderInfoListByServiceId(
+ serviceId, isTagService, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 1);
+
+ Mockito.verify(securityZoneRest).getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request);
+ }
+
+ @Test
+ public void test78getAllZones() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerSecurityZone> zones = new ArrayList<>();
+ RangerSecurityZone zone = new RangerSecurityZone();
+ zone.setId(Id);
+ zone.setName("test-zone");
+ zones.add(zone);
+
+ RangerSecurityZoneList zoneList = new RangerSecurityZoneList(zones);
+
+ Mockito.when(securityZoneRest.getAllZones(request)).thenReturn(zoneList);
+
+ List<RangerSecurityZone> result = publicAPIsv2.getAllZones(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 1);
+
+ Mockito.verify(securityZoneRest).getAllZones(request);
+ }
+
+ @Test
+ public void test79deleteBulkPolicies() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "hdfs_service";
+ List<Long> deletedPolicyIds = new ArrayList<>();
+ deletedPolicyIds.add(1L);
+ deletedPolicyIds.add(2L);
+
+ Mockito.when(serviceREST.deleteBulkPolicies(Mockito.eq(serviceName), Mockito.eq(request))).thenReturn(deletedPolicyIds);
+
+ List<Long> result = publicAPIsv2.deletePolicies(request, serviceName);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.size(), 2);
+
+ Mockito.verify(serviceREST).deleteBulkPolicies(Mockito.eq(serviceName), Mockito.eq(request));
+ }
+
+ @Test
+ public void test80purgeEmptyPoliciesWithNullServiceName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ publicAPIsv2.purgeEmptyPolicies(null, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
}
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestRoleREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestRoleREST.java
index ae2095d49..438b17d6b 100644
--- a/security-admin/src/test/java/org/apache/ranger/rest/TestRoleREST.java
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestRoleREST.java
@@ -54,20 +54,23 @@
import org.apache.ranger.service.XUserService;
import org.apache.ranger.view.RangerRoleList;
import org.apache.ranger.view.VXUser;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.AdditionalAnswers;
import org.mockito.Answers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.WebApplicationException;
import java.io.File;
import java.io.FileInputStream;
@@ -85,7 +88,12 @@
import static org.mockito.ArgumentMatchers.eq;
-@RunWith(MockitoJUnitRunner.class)
+/**
+* @generated by Cursor
+* @description <Unit Test for TestRoleREST class>
+*/
+@ExtendWith(MockitoExtension.class)
+@TestMethodOrder(MethodOrderer.MethodName.class)
public class TestRoleREST {
private static final Long userId = 8L;
private static final Long roleId = 9L;
@@ -144,7 +152,7 @@ public class TestRoleREST {
@InjectMocks private RoleREST roleRest = new RoleREST();
- @Before
+ @BeforeEach
public void setup() {
RangerSecurityContext context = new RangerSecurityContext();
context.setUserSession(new UserSessionBase());
@@ -157,7 +165,7 @@ public void setup() {
currentUserSession.setXXPortalUser(xXPortalUser);
}
- @After
+ @AfterEach
public void destroySession() {
RangerSecurityContext context = new RangerSecurityContext();
context.setUserSession(null);
@@ -176,10 +184,10 @@ public void test1CreateRole() {
throw new RuntimeException(e);
}
RangerRole createdRole = roleRest.createRole("admin", rangerRole, createNonExistUserGroup);
- Assert.assertNotNull(createdRole);
- Assert.assertEquals(createdRole.getName(), rangerRole.getName());
- Assert.assertEquals(createdRole.getDescription(), rangerRole.getDescription());
- Assert.assertEquals(createdRole.getCreatedByUser(), rangerRole.getCreatedByUser());
+ Assertions.assertNotNull(createdRole);
+ Assertions.assertEquals(createdRole.getName(), rangerRole.getName());
+ Assertions.assertEquals(createdRole.getDescription(), rangerRole.getDescription());
+ Assertions.assertEquals(createdRole.getCreatedByUser(), rangerRole.getCreatedByUser());
}
@Test
@@ -190,7 +198,6 @@ public void test2UpdateRole() {
Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenReturn(Mockito.mock(RangerRoleValidator.class));
XXRoleDao xxRoleDao = Mockito.mock(XXRoleDao.class);
Mockito.when(daoMgr.getXXRole()).thenReturn(xxRoleDao);
- Mockito.when(daoMgr.getXXPolicyRefRole().findRoleRefPolicyCount(Mockito.anyString())).thenReturn(0L);
try {
Mockito.when(roleStore.getRole(Mockito.anyLong())).thenReturn(rangerRoleOld);
} catch (Exception e) {
@@ -202,9 +209,9 @@ public void test2UpdateRole() {
throw new RuntimeException(e);
}
RangerRole updatedRole = roleRest.updateRole(roleId, rangerRole, eq(createNonExistUserGroup));
- Assert.assertNotNull(updatedRole);
- Assert.assertEquals(updatedRole.getName(), rangerRole.getName());
- Assert.assertEquals(updatedRole.getUsers(), rangerRole.getUsers());
+ Assertions.assertNotNull(updatedRole);
+ Assertions.assertEquals(updatedRole.getName(), rangerRole.getName());
+ Assertions.assertEquals(updatedRole.getUsers(), rangerRole.getUsers());
}
@Test
@@ -243,8 +250,8 @@ public void test5GetRoleByName() {
throw new RuntimeException(e);
}
RangerRole returnedRole = roleRest.getRole("admin", adminLoginID, rangerRole.getName());
- Assert.assertNotNull(returnedRole);
- Assert.assertEquals(returnedRole.getName(), rangerRole.getName());
+ Assertions.assertNotNull(returnedRole);
+ Assertions.assertEquals(returnedRole.getName(), rangerRole.getName());
}
@Test
@@ -256,9 +263,9 @@ public void test6GetRoleById() {
throw new RuntimeException(e);
}
RangerRole returnedRole = roleRest.getRole(eq(rangerRole.getId()));
- Assert.assertNotNull(returnedRole);
- Assert.assertEquals(returnedRole.getName(), rangerRole.getName());
- Assert.assertEquals(returnedRole.getId(), rangerRole.getId());
+ Assertions.assertNotNull(returnedRole);
+ Assertions.assertEquals(returnedRole.getName(), rangerRole.getName());
+ Assertions.assertEquals(returnedRole.getId(), rangerRole.getId());
}
@Test
@@ -267,8 +274,8 @@ public void test7GetAllRoles() {
Mockito.when(searchUtil.getSearchFilter(Mockito.any(HttpServletRequest.class), eq(roleService.sortFields))).thenReturn(Mockito.mock(SearchFilter.class));
Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
RangerRoleList returnedRangerRoleList = roleRest.getAllRoles(Mockito.mock(HttpServletRequest.class));
- Assert.assertNotNull(returnedRangerRoleList);
- Assert.assertEquals(returnedRangerRoleList.getListSize(), rangerRoleList.getListSize());
+ Assertions.assertNotNull(returnedRangerRoleList);
+ Assertions.assertEquals(returnedRangerRoleList.getListSize(), rangerRoleList.getListSize());
}
@Test
@@ -277,8 +284,8 @@ public void test8GetAllRolesForUser() {
SearchFilter searchFilter = new SearchFilter();
Mockito.when(searchUtil.getSearchFilter(Mockito.any(HttpServletRequest.class), eq(roleService.sortFields))).thenReturn(searchFilter);
RangerRoleList returnedRangerRoleList = roleRest.getAllRolesForUser(Mockito.mock(HttpServletRequest.class));
- Assert.assertNotNull(returnedRangerRoleList);
- Assert.assertEquals(returnedRangerRoleList.getListSize(), rangerRoleList.getListSize());
+ Assertions.assertNotNull(returnedRangerRoleList);
+ Assertions.assertEquals(returnedRangerRoleList.getListSize(), rangerRoleList.getListSize());
}
@Test
@@ -292,8 +299,8 @@ public void test9GetAllRoleNames() {
throw new RuntimeException(e);
}
List<String> returnedRoleList = roleRest.getAllRoleNames(adminLoginID, adminLoginID, Mockito.mock(HttpServletRequest.class));
- Assert.assertNotNull(returnedRoleList);
- Assert.assertEquals(returnedRoleList.size(), roleList.size());
+ Assertions.assertNotNull(returnedRoleList);
+ Assertions.assertEquals(returnedRoleList.size(), roleList.size());
}
@Test
@@ -314,9 +321,9 @@ public void test10AddUsersAndGroups() {
throw new RuntimeException(e);
}
RangerRole returnedRole = roleRest.addUsersAndGroups(roleId, users, groups, isAdmin);
- Assert.assertNotNull(returnedRole);
- Assert.assertEquals(returnedRole.getUsers().size(), users.size());
- Assert.assertEquals(returnedRole.getGroups().size(), groups.size());
+ Assertions.assertNotNull(returnedRole);
+ Assertions.assertEquals(returnedRole.getUsers().size(), users.size());
+ Assertions.assertEquals(returnedRole.getGroups().size(), groups.size());
}
@Test
@@ -344,21 +351,21 @@ public void test11RemoveUsersAndGroups() {
throw new RuntimeException(e);
}
RangerRole returnedRole = roleRest.removeUsersAndGroups(roleId, users, groups);
- Assert.assertNotNull(returnedRole);
- Assert.assertEquals(createdRoleUsers, users);
- Assert.assertEquals(createdRoleGroups, groups);
- Assert.assertEquals(0, returnedRole.getUsers().size());
- Assert.assertEquals(0, returnedRole.getGroups().size());
+ Assertions.assertNotNull(returnedRole);
+ Assertions.assertEquals(createdRoleUsers, users);
+ Assertions.assertEquals(createdRoleGroups, groups);
+ Assertions.assertEquals(returnedRole.getUsers().size(), 0);
+ Assertions.assertEquals(returnedRole.getGroups().size(), 0);
}
@Test
public void test12RemoveAdminFromUsersAndGroups() {
RangerRole rangerRole = createRoleWithUsersAndGroups();
for (RangerRole.RoleMember role : rangerRole.getUsers()) {
- Assert.assertTrue(role.getIsAdmin());
+ Assertions.assertTrue(role.getIsAdmin());
}
for (RangerRole.RoleMember group : rangerRole.getGroups()) {
- Assert.assertTrue(group.getIsAdmin());
+ Assertions.assertTrue(group.getIsAdmin());
}
List<String> users = new ArrayList<>(Arrays.asList("test-role", "admin"));
List<String> groups = new ArrayList<>(Arrays.asList("test-group", "admin"));
@@ -382,14 +389,14 @@ public void test12RemoveAdminFromUsersAndGroups() {
throw new RuntimeException(e);
}
RangerRole returnedRole = roleRest.removeAdminFromUsersAndGroups(roleId, users, groups);
- Assert.assertNotNull(returnedRole);
- Assert.assertEquals(createdRoleUsers, users);
- Assert.assertEquals(createdRoleGroups, groups);
+ Assertions.assertNotNull(returnedRole);
+ Assertions.assertEquals(createdRoleUsers, users);
+ Assertions.assertEquals(createdRoleGroups, groups);
for (RangerRole.RoleMember role : returnedRole.getUsers()) {
- Assert.assertFalse(role.getIsAdmin());
+ Assertions.assertFalse(role.getIsAdmin());
}
for (RangerRole.RoleMember group : returnedRole.getGroups()) {
- Assert.assertFalse(group.getIsAdmin());
+ Assertions.assertFalse(group.getIsAdmin());
}
}
@@ -410,8 +417,8 @@ public void test13GrantRole() {
throw new RuntimeException(e);
}
RESTResponse resp = roleRest.grantRole(serviceName, grantRevokeRoleRequest, Mockito.mock(HttpServletRequest.class));
- Assert.assertNotNull(resp);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, resp.getStatusCode());
+ Assertions.assertNotNull(resp);
+ Assertions.assertEquals(resp.getStatusCode(), RESTResponse.STATUS_SUCCESS);
}
@Test
@@ -431,8 +438,8 @@ public void test14RevokeRole() {
throw new RuntimeException(e);
}
RESTResponse resp = roleRest.revokeRole(serviceName, grantRevokeRoleRequest, Mockito.mock(HttpServletRequest.class));
- Assert.assertNotNull(resp);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, resp.getStatusCode());
+ Assertions.assertNotNull(resp);
+ Assertions.assertEquals(resp.getStatusCode(), RESTResponse.STATUS_SUCCESS);
}
@Test
@@ -453,8 +460,8 @@ public void test15GetUserRoles() {
throw new RuntimeException(e);
}
List<String> returnedRoles = roleRest.getUserRoles(adminLoginID, Mockito.mock(HttpServletRequest.class));
- Assert.assertNotNull(returnedRoles);
- Assert.assertEquals(returnedRoles.size(), rangerRoles.size());
+ Assertions.assertNotNull(returnedRoles);
+ Assertions.assertEquals(returnedRoles.size(), rangerRoles.size());
}
@Test
@@ -476,8 +483,8 @@ public void test16GetRangerRolesIfUpdated() {
} catch (Exception e) {
throw new RuntimeException(e);
}
- Assert.assertNotNull(returnedRangeRoles);
- Assert.assertEquals(returnedRangeRoles.getRangerRoles().size(), rangerRoles.getRangerRoles().size());
+ Assertions.assertNotNull(returnedRangeRoles);
+ Assertions.assertEquals(returnedRangeRoles.getRangerRoles().size(), rangerRoles.getRangerRoles().size());
}
@Test
@@ -501,88 +508,91 @@ public void test17GetSecureRangerRolesIfUpdated() {
} catch (Exception e) {
throw new RuntimeException(e);
}
- Assert.assertNotNull(returnedRangeRoles);
- Assert.assertEquals(returnedRangeRoles.getRangerRoles().size(), rangerRoles.getRangerRoles().size());
+ Assertions.assertNotNull(returnedRangeRoles);
+ Assertions.assertEquals(returnedRangeRoles.getRangerRoles().size(), rangerRoles.getRangerRoles().size());
}
- @Test(expected = Throwable.class)
+ @Test
public void test1bCreateRole() {
boolean createNonExistUserGroup = true;
Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenReturn(Mockito.mock(RangerRoleValidator.class));
Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
RangerRole rangerRole = createRoleInvalidMember();
- roleRest.createRole("admin", rangerRole, createNonExistUserGroup);
+ Assertions.assertThrows(Throwable.class, () -> roleRest.createRole("admin", rangerRole, createNonExistUserGroup));
}
- @Test(expected = Throwable.class)
+ @Test
public void test2bUpdateRole() {
- Boolean createNonExistUserGroup = Boolean.TRUE;
- RangerRole rangerRole = createRoleInvalidMember();
- RangerRole rangerRoleOld = createRoleOld();
- Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenReturn(Mockito.mock(RangerRoleValidator.class));
- XXRoleDao xxRoleDao = Mockito.mock(XXRoleDao.class);
- Mockito.when(daoMgr.getXXRole()).thenReturn(xxRoleDao);
- Mockito.when(daoMgr.getXXPolicyRefRole().findRoleRefPolicyCount(Mockito.anyString())).thenReturn(0L);
- try {
- Mockito.when(roleStore.getRole(Mockito.anyLong())).thenReturn(rangerRoleOld);
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- roleRest.updateRole(roleId, rangerRole, eq(createNonExistUserGroup));
+ Assertions.assertThrows(Throwable.class, () -> {
+ Boolean createNonExistUserGroup = Boolean.TRUE;
+ RangerRole rangerRole = createRoleInvalidMember();
+ RangerRole rangerRoleOld = createRoleOld();
+ Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenReturn(Mockito.mock(RangerRoleValidator.class));
+ XXRoleDao xxRoleDao = Mockito.mock(XXRoleDao.class);
+ Mockito.when(daoMgr.getXXRole()).thenReturn(xxRoleDao);
+ try {
+ Mockito.when(roleStore.getRole(Mockito.anyLong())).thenReturn(rangerRoleOld);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ roleRest.updateRole(roleId, rangerRole, eq(createNonExistUserGroup));
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test3bDeleteRoleByName() {
RangerRole rangerRole = createRole();
Mockito.doReturn(false).when(bizUtil).isUserRangerAdmin(Mockito.anyString());
Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenReturn(Mockito.mock(RangerRoleValidator.class));
- roleRest.deleteRole("admin", adminLoginID, rangerRole.getName());
- try {
- Mockito.verify(roleStore, Mockito.times(1)).deleteRole(Mockito.anyString());
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ Assertions.assertThrows(Throwable.class, () -> {
+ roleRest.deleteRole("admin", adminLoginID, rangerRole.getName());
+ try {
+ Mockito.verify(roleStore, Mockito.times(1)).deleteRole(Mockito.anyString());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test4bDeleteRoleById() {
RangerRole rangerRole = createRole();
Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenReturn(Mockito.mock(RangerRoleValidator.class));
- roleRest.deleteRole(rangerRole.getId());
- try {
- Mockito.verify(roleStore, Mockito.times(1)).deleteRole(Mockito.anyLong());
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ Assertions.assertThrows(Throwable.class, () -> {
+ roleRest.deleteRole(rangerRole.getId());
+ try {
+ Mockito.verify(roleStore, Mockito.times(1)).deleteRole(Mockito.anyLong());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test5bGetRoleByName() {
RangerRole rangerRole = createRole();
- roleRest.getRole("admin", adminLoginID, rangerRole.getName());
+ Assertions.assertThrows(Throwable.class, () -> roleRest.getRole("admin", adminLoginID, rangerRole.getName()));
}
- @Test(expected = Throwable.class)
+ @Test
public void test6bGetRoleById() {
RangerRole rangerRole = createRole();
- try {
- Mockito.when(roleStore.getRole(Mockito.anyLong())).thenThrow(new Exception("test"));
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- roleRest.getRole(eq(rangerRole.getId()));
+ Mockito.when(roleStore.getRole(Mockito.anyLong())).thenThrow(new RuntimeException("test"));
+ Assertions.assertThrows(Throwable.class, () -> roleRest.getRole(eq(rangerRole.getId())));
}
- @Test(expected = Throwable.class)
+ @Test
public void test7bGetAllRoles() {
- SearchFilter searchFilter = new SearchFilter();
- try {
- Mockito.when(roleStore.getRoles(searchFilter, Mockito.any(RangerRoleList.class))).thenThrow(new Exception("test"));
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- Mockito.when(searchUtil.getSearchFilter(Mockito.any(HttpServletRequest.class), eq(roleService.sortFields))).thenReturn(Mockito.mock(SearchFilter.class));
- roleRest.getAllRoles(Mockito.mock(HttpServletRequest.class));
+ Assertions.assertThrows(Throwable.class, () -> {
+ SearchFilter searchFilter = new SearchFilter();
+ try {
+ Mockito.when(roleStore.getRoles(searchFilter, Mockito.any(RangerRoleList.class))).thenThrow(new Exception("test"));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ Mockito.when(searchUtil.getSearchFilter(Mockito.any(HttpServletRequest.class), eq(roleService.sortFields))).thenReturn(Mockito.mock(SearchFilter.class));
+ roleRest.getAllRoles(Mockito.mock(HttpServletRequest.class));
+ });
}
@Test
@@ -591,26 +601,28 @@ public void test8bGetAllRolesForUser() {
SearchFilter searchFilter = new SearchFilter();
Mockito.when(searchUtil.getSearchFilter(Mockito.any(HttpServletRequest.class), eq(roleService.sortFields))).thenReturn(searchFilter);
RangerRoleList returnedRangerRoleList = roleRest.getAllRolesForUser(Mockito.mock(HttpServletRequest.class));
- Assert.assertNotNull(returnedRangerRoleList);
- Assert.assertEquals(returnedRangerRoleList.getListSize(), rangerRoleList.getListSize());
+ Assertions.assertNotNull(returnedRangerRoleList);
+ Assertions.assertEquals(returnedRangerRoleList.getListSize(), rangerRoleList.getListSize());
}
- @Test(expected = Throwable.class)
+ @Test
public void test9bGetAllRoleNames() {
- List<String> roleList = createRoleList();
- Mockito.when(searchUtil.getSearchFilter(Mockito.any(HttpServletRequest.class), eq(roleService.sortFields))).thenReturn(Mockito.mock(SearchFilter.class));
- List<String> returnedRoleList = roleRest.getAllRoleNames(adminLoginID, adminLoginID, Mockito.mock(HttpServletRequest.class));
- Assert.assertNotNull(returnedRoleList);
- Assert.assertEquals(returnedRoleList.size(), roleList.size());
+ Assertions.assertThrows(Throwable.class, () -> {
+ List<String> roleList = createRoleList();
+ Mockito.when(searchUtil.getSearchFilter(Mockito.any(HttpServletRequest.class), eq(roleService.sortFields))).thenReturn(Mockito.mock(SearchFilter.class));
+ List<String> returnedRoleList = roleRest.getAllRoleNames(adminLoginID, adminLoginID, Mockito.mock(HttpServletRequest.class));
+ Assertions.assertNotNull(returnedRoleList);
+ Assertions.assertEquals(returnedRoleList.size(), roleList.size());
+ });
}
@Test
public void test10bAddUsersAndGroups() {
RangerRole rangerRole = createRoleWithUsersAndGroups();
- int currentUsersCount = rangerRole.getUsers().size();
int currentGroupsCount = rangerRole.getGroups().size();
List<String> users = new ArrayList<>(Arrays.asList("test-role2", "test-role3"));
List<String> groups = new ArrayList<>(Arrays.asList("test-group2", "test-group3"));
+ Boolean isAdmin = Boolean.TRUE;
Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
try {
Mockito.when(roleStore.getRole(Mockito.anyLong())).thenReturn(rangerRole);
@@ -622,52 +634,61 @@ public void test10bAddUsersAndGroups() {
} catch (Exception e) {
throw new RuntimeException(e);
}
- RangerRole returnedRole = roleRest.addUsersAndGroups(roleId, users, groups, true);
- Assert.assertNotNull(returnedRole);
- Assert.assertEquals(returnedRole.getGroups().size(), groups.size() + currentGroupsCount);
+ RangerRole returnedRole = roleRest.addUsersAndGroups(roleId, users, groups, isAdmin);
+ Assertions.assertNotNull(returnedRole);
+ Assertions.assertEquals(returnedRole.getGroups().size(), groups.size() + currentGroupsCount);
}
- @Test(expected = Throwable.class)
+ @Test
public void test10cAddUsersAndGroups() {
- RangerRole rangerRole = createRole();
- List<String> users = new ArrayList<>(Arrays.asList("{OWNER}", "test-role3"));
- List<String> groups = new ArrayList<>(Arrays.asList("test-group2", "test-group3"));
- roleRest.addUsersAndGroups(roleId, users, groups, true);
+ Assertions.assertThrows(Throwable.class, () -> {
+ createRole();
+ List<String> users = new ArrayList<>(Arrays.asList("{OWNER}", "test-role3"));
+ List<String> groups = new ArrayList<>(Arrays.asList("test-group2", "test-group3"));
+ Boolean isAdmin = Boolean.TRUE;
+ roleRest.addUsersAndGroups(roleId, users, groups, isAdmin);
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test11bRemoveUsersAndGroups() {
- RangerRole rangerRole = createRole();
- List<String> users = new ArrayList<>(Arrays.asList("test-role", "admin"));
- List<String> groups = new ArrayList<>();
- List<String> createdRoleUsers = new ArrayList<>();
- for (RangerRole.RoleMember roleMember : rangerRole.getUsers()) {
- createdRoleUsers.add(roleMember.getName());
- }
- roleRest.removeUsersAndGroups(roleId, users, groups);
+ Assertions.assertThrows(Throwable.class, () -> {
+ RangerRole rangerRole = createRole();
+ List<String> users = new ArrayList<>(Arrays.asList("test-role", "admin"));
+ List<String> groups = new ArrayList<>();
+ List<String> createdRoleUsers = new ArrayList<>();
+ for (RangerRole.RoleMember roleMember : rangerRole.getUsers()) {
+ createdRoleUsers.add(roleMember.getName());
+ }
+ roleRest.removeUsersAndGroups(roleId, users, groups);
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test12bRemoveAdminFromUsersAndGroups() {
- RangerRole rangerRole = createRole();
- for (RangerRole.RoleMember role : rangerRole.getUsers()) {
- Assert.assertTrue(role.getIsAdmin());
- }
- List<String> users = new ArrayList<>(Arrays.asList("test-role", "admin"));
- List<String> groups = new ArrayList<>();
- List<String> createdRoleUsers = new ArrayList<>();
- for (RangerRole.RoleMember roleMember : rangerRole.getUsers()) {
- createdRoleUsers.add(roleMember.getName());
- }
- roleRest.removeAdminFromUsersAndGroups(roleId, users, groups);
+ Assertions.assertThrows(Throwable.class, () -> {
+ RangerRole rangerRole = createRole();
+ for (RangerRole.RoleMember role : rangerRole.getUsers()) {
+ Assertions.assertTrue(role.getIsAdmin());
+ }
+ List<String> users = new ArrayList<>(Arrays.asList("test-role", "admin"));
+ List<String> groups = new ArrayList<>();
+ List<String> createdRoleUsers = new ArrayList<>();
+ for (RangerRole.RoleMember roleMember : rangerRole.getUsers()) {
+ createdRoleUsers.add(roleMember.getName());
+ }
+ roleRest.removeAdminFromUsersAndGroups(roleId, users, groups);
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test13bGrantRole() {
- RangerRole rangerRole = createRole();
- String serviceName = "serviceName";
- GrantRevokeRoleRequest grantRevokeRoleRequest = createGrantRevokeRoleRequest();
- roleRest.grantRole(serviceName, grantRevokeRoleRequest, Mockito.mock(HttpServletRequest.class));
+ Assertions.assertThrows(Throwable.class, () -> {
+ createRole();
+ String serviceName = "serviceName";
+ GrantRevokeRoleRequest grantRevokeRoleRequest = createGrantRevokeRoleRequest();
+ roleRest.grantRole(serviceName, grantRevokeRoleRequest, Mockito.mock(HttpServletRequest.class));
+ });
}
@Test
@@ -688,129 +709,142 @@ public void test14bRevokeRole() {
throw new RuntimeException(e);
}
RESTResponse resp = roleRest.revokeRole(serviceName, grantRevokeRoleRequest, Mockito.mock(HttpServletRequest.class));
- Assert.assertNotNull(resp);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, resp.getStatusCode());
+ Assertions.assertNotNull(resp);
+ Assertions.assertEquals(resp.getStatusCode(), RESTResponse.STATUS_SUCCESS);
}
- @Test(expected = Throwable.class)
+ @Test
public void test14cRevokeRole() {
- RangerRole rangerRole = createRole();
- String serviceName = "serviceName";
- GrantRevokeRoleRequest grantRevokeRoleRequest = createGrantRevokeRoleRequest();
- grantRevokeRoleRequest.setGrantOption(Boolean.TRUE);
- grantRevokeRoleRequest.setGrantorGroups(new HashSet<>(Arrays.asList("group1", "group2")));
- roleRest.revokeRole(serviceName, grantRevokeRoleRequest, Mockito.mock(HttpServletRequest.class));
+ Assertions.assertThrows(Throwable.class, () -> {
+ createRole();
+ String serviceName = "serviceName";
+ GrantRevokeRoleRequest grantRevokeRoleRequest = createGrantRevokeRoleRequest();
+ grantRevokeRoleRequest.setGrantOption(Boolean.TRUE);
+ grantRevokeRoleRequest.setGrantorGroups(new HashSet<>(Arrays.asList("group1", "group2")));
+ roleRest.revokeRole(serviceName, grantRevokeRoleRequest, Mockito.mock(HttpServletRequest.class));
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test15bGetUserRoles() {
- Set<RangerRole> rangerRoles = new HashSet<>();
- RangerRole rangerRole = createRole();
- rangerRoles.add(rangerRole);
- List<XXRoleRefGroup> xxRoleRefGroupList = createXXRoleRefGroupList();
- List<XXRoleRefUser> xxRoleRefRoleList = createXXRoleRefUserList();
- Set<String> groups = new HashSet<>(Arrays.asList("group1", "group2"));
- Mockito.when(xUserService.getXUserByUserName(Mockito.anyString())).thenReturn(null);
- Mockito.when(roleRefUpdater.getRangerDaoManager().getXXRoleRefUser().findByUserName(adminLoginID)).thenReturn(xxRoleRefRoleList);
- Mockito.when(roleRefUpdater.getRangerDaoManager().getXXRoleRefGroup().findByGroupName(adminLoginID)).thenReturn(xxRoleRefGroupList);
- roleRest.getUserRoles(adminLoginID, Mockito.mock(HttpServletRequest.class));
+ Assertions.assertThrows(Throwable.class, () -> {
+ Set<RangerRole> rangerRoles = new HashSet<>();
+ RangerRole rangerRole = createRole();
+ rangerRoles.add(rangerRole);
+ List<XXRoleRefGroup> xxRoleRefGroupList = createXXRoleRefGroupList();
+ List<XXRoleRefUser> xxRoleRefRoleList = createXXRoleRefUserList();
+ Mockito.when(xUserService.getXUserByUserName(Mockito.anyString())).thenReturn(null);
+ Mockito.when(roleRefUpdater.getRangerDaoManager().getXXRoleRefUser().findByUserName(adminLoginID)).thenReturn(xxRoleRefRoleList);
+ Mockito.when(roleRefUpdater.getRangerDaoManager().getXXRoleRefGroup().findByGroupName(adminLoginID)).thenReturn(xxRoleRefGroupList);
+ roleRest.getUserRoles(adminLoginID, Mockito.mock(HttpServletRequest.class));
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test16bGetRangerRolesIfUpdated() {
- RangerRoles rangerRoles = createRangerRoles();
- String serviceName = "serviceName";
- String pluginId = "pluginId";
- String clusterName = "";
- String pluginCapabilities = "";
- try {
- Mockito.doThrow(new Exception()).when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- try {
- roleRest.getRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ Assertions.assertThrows(Throwable.class, () -> {
+ createRangerRoles();
+ String serviceName = "serviceName";
+ String pluginId = "pluginId";
+ String clusterName = "";
+ String pluginCapabilities = "";
+ try {
+ Mockito.doThrow(new Exception()).when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ try {
+ roleRest.getRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test16cGetRangerRolesIfUpdated() {
- String serviceName = "serviceName";
- String pluginId = "pluginId";
- String clusterName = "";
- String pluginCapabilities = "";
- Mockito.when(serviceUtil.isValidService(Mockito.anyString(), Mockito.any(HttpServletRequest.class))).thenReturn(true);
- try {
- Mockito.when(roleStore.getRoles(Mockito.anyString(), Mockito.anyLong())).thenReturn(null);
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- try {
- roleRest.getRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ Assertions.assertThrows(Throwable.class, () -> {
+ String serviceName = "serviceName";
+ String pluginId = "pluginId";
+ String clusterName = "";
+ String pluginCapabilities = "";
+ Mockito.when(serviceUtil.isValidService(Mockito.anyString(), Mockito.any(HttpServletRequest.class))).thenReturn(true);
+ try {
+ Mockito.when(roleStore.getRoles(Mockito.anyString(), Mockito.anyLong())).thenReturn(null);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ try {
+ roleRest.getRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test17bGetSecureRangerRolesIfUpdated() {
- RangerRoles rangerRoles = createRangerRoles();
- String serviceName = "serviceName";
- String pluginId = "pluginId";
- String clusterName = "";
- String pluginCapabilities = "";
- Mockito.when(serviceUtil.isValidService(eq(null), Mockito.any(HttpServletRequest.class))).thenThrow(new Exception());
- try {
- Mockito.when(roleStore.getRoles(Mockito.anyString(), Mockito.anyLong())).thenReturn(rangerRoles);
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- Mockito.when(daoMgr.getXXService().findByName(Mockito.anyString())).thenReturn(createXXService());
- Mockito.when(bizUtil.isAdmin()).thenReturn(true);
- try {
- roleRest.getSecureRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ Assertions.assertThrows(Throwable.class, () -> {
+ RangerRoles rangerRoles = createRangerRoles();
+ String serviceName = "serviceName";
+ String pluginId = "pluginId";
+ String clusterName = "";
+ String pluginCapabilities = "";
+ Mockito.when(serviceUtil.isValidService(eq(null), Mockito.any(HttpServletRequest.class))).thenThrow(new Exception());
+ try {
+ Mockito.when(roleStore.getRoles(Mockito.anyString(), Mockito.anyLong())).thenReturn(rangerRoles);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ Mockito.when(daoMgr.getXXService().findByName(Mockito.anyString())).thenReturn(createXXService());
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
+ try {
+ roleRest.getSecureRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test17cGetSecureRangerRolesIfUpdated() {
- String serviceName = "serviceName";
- String pluginId = "pluginId";
- String clusterName = "";
- String pluginCapabilities = "";
- Mockito.when(serviceUtil.isValidService(Mockito.anyString(), Mockito.any(HttpServletRequest.class))).thenReturn(true);
- Mockito.when(daoMgr.getXXService().findByName(Mockito.anyString())).thenReturn(null);
- Mockito.when(bizUtil.isAdmin()).thenReturn(true);
- try {
- roleRest.getSecureRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ Assertions.assertThrows(Throwable.class, () -> {
+ String serviceName = "serviceName";
+ String pluginId = "pluginId";
+ String clusterName = "";
+ String pluginCapabilities = "";
+ Mockito.when(serviceUtil.isValidService(Mockito.anyString(), Mockito.any(HttpServletRequest.class))).thenReturn(true);
+ Mockito.when(daoMgr.getXXService().findByName(Mockito.anyString())).thenReturn(null);
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
+ try {
+ roleRest.getSecureRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test17dGetSecureRangerRolesIfUpdated() {
- String serviceName = "serviceName";
- String pluginId = "pluginId";
- String clusterName = "";
- String pluginCapabilities = "";
- Mockito.when(serviceUtil.isValidService(Mockito.anyString(), Mockito.any(HttpServletRequest.class))).thenReturn(true);
- try {
- Mockito.when(roleStore.getRoles(Mockito.anyString(), Mockito.anyLong())).thenReturn(null);
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- Mockito.when(daoMgr.getXXService().findByName(Mockito.anyString())).thenReturn(createXXService());
- Mockito.when(bizUtil.isAdmin()).thenReturn(true);
- try {
- roleRest.getSecureRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ Assertions.assertThrows(Throwable.class, () -> {
+ String serviceName = "serviceName";
+ String pluginId = "pluginId";
+ String clusterName = "";
+ String pluginCapabilities = "";
+ Mockito.when(serviceUtil.isValidService(Mockito.anyString(), Mockito.any(HttpServletRequest.class))).thenReturn(true);
+ try {
+ Mockito.when(roleStore.getRoles(Mockito.anyString(), Mockito.anyLong())).thenReturn(null);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ Mockito.when(daoMgr.getXXService().findByName(Mockito.anyString())).thenReturn(createXXService());
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
+ try {
+ roleRest.getSecureRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
}
// empty request roles (requestParamRoles = 0, dbRoles = 5, return = all dbRoles)
@@ -880,22 +914,24 @@ public void test18cGetRolesInJson() throws Exception {
}
// getAllFilteredRoleList throws Exception
- @Test(expected = Throwable.class)
+ @Test
public void test18dGetRolesInJson() throws Exception {
// pre-requisites
- List<RangerRole> rangerRolesProcessed = new ArrayList<>();
+ Assertions.assertThrows(Throwable.class, () -> {
+ List<RangerRole> rangerRolesProcessed = new ArrayList<>();
- // mock
- HttpServletRequest requestMock = Mockito.mock(HttpServletRequest.class);
- HttpServletResponse responseMock = Mockito.mock(HttpServletResponse.class);
+ // mock
+ HttpServletRequest requestMock = Mockito.mock(HttpServletRequest.class);
+ HttpServletResponse responseMock = Mockito.mock(HttpServletResponse.class);
- // stubs
- Mockito.when(roleRest.getAllFilteredRoleList(requestMock)).thenThrow(new Throwable());
+ // stubs
+ Mockito.when(roleRest.getAllFilteredRoleList(requestMock)).thenThrow(new Throwable());
- // test
- Assert.assertThrows(Throwable.class, () -> roleRest.getRolesInJson(requestMock, responseMock));
- Mockito.verify(svcStore, Mockito.never()).getObjectInJson(rangerRolesProcessed, responseMock, ROLE);
- Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+ // test
+ roleRest.getRolesInJson(requestMock, responseMock);
+ Mockito.verify(svcStore, Mockito.never()).getObjectInJson(rangerRolesProcessed, responseMock, ROLE);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+ });
}
// full match: requestParamRoles = 0, dbRoles = 5, return = all dbRoles
@@ -923,9 +959,9 @@ public void test19GetAllFilteredRoleList() throws Exception {
// test
List<RangerRole> rangerRolesProcessedActual = roleRest.getAllFilteredRoleList(requestMock);
- Assert.assertNotNull(rangerRolesProcessedActual);
- Assert.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
- Assert.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
+ Assertions.assertNotNull(rangerRolesProcessedActual);
+ Assertions.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
+ Assertions.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
}
// partial match: requestParamRoles = 2, dbRoles = 5, match = 2
@@ -958,9 +994,9 @@ public void test19bGetAllFilteredRoleList() throws Exception {
// test
List<RangerRole> rangerRolesProcessedActual = roleRest.getAllFilteredRoleList(requestMock);
- Assert.assertNotNull(rangerRolesProcessedActual);
- Assert.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
- Assert.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
+ Assertions.assertNotNull(rangerRolesProcessedActual);
+ Assertions.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
+ Assertions.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
}
// partial match: requestParamRoles = 4, dbRoles = 5, match = 2
@@ -993,9 +1029,9 @@ public void test19cGetAllFilteredRoleList() throws Exception {
// test
List<RangerRole> rangerRolesProcessedActual = roleRest.getAllFilteredRoleList(requestMock);
- Assert.assertNotNull(rangerRolesProcessedActual);
- Assert.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
- Assert.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
+ Assertions.assertNotNull(rangerRolesProcessedActual);
+ Assertions.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
+ Assertions.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
}
// no match: requestParamRoles = 3, dbRoles = 5, match = 0
@@ -1025,9 +1061,9 @@ public void test19dGetAllFilteredRoleList() throws Exception {
// test
List<RangerRole> rangerRolesProcessedActual = roleRest.getAllFilteredRoleList(requestMock);
- Assert.assertNotNull(rangerRolesProcessedActual);
- Assert.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
- Assert.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
+ Assertions.assertNotNull(rangerRolesProcessedActual);
+ Assertions.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
+ Assertions.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
}
// no match: requestParamRoles = 3, dbRoles = 0, match = 0
@@ -1047,9 +1083,9 @@ public void test19eGetAllFilteredRoleList() throws Exception {
// test
List<RangerRole> rangerRolesProcessedActual = roleRest.getAllFilteredRoleList(requestMock);
- Assert.assertNotNull(rangerRolesProcessedActual);
- Assert.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
- Assert.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
+ Assertions.assertNotNull(rangerRolesProcessedActual);
+ Assertions.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
+ Assertions.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
}
// full match: requestParamRoles = null, dbRoles = 5, return = all dbRoles
@@ -1077,9 +1113,9 @@ public void test19fGetAllFilteredRoleList() throws Exception {
// test
List<RangerRole> rangerRolesProcessedActual = roleRest.getAllFilteredRoleList(requestMock);
- Assert.assertNotNull(rangerRolesProcessedActual);
- Assert.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
- Assert.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
+ Assertions.assertNotNull(rangerRolesProcessedActual);
+ Assertions.assertEquals(rangerRolesProcessedActual.size(), rangerRolesProcessedExpected.size());
+ Assertions.assertEquals(rangerRolesProcessedActual, rangerRolesProcessedExpected);
}
// import role with updateIfExists=false and createNonExistUserGroupRole=false
@@ -1093,20 +1129,20 @@ public void test20importRolesFromFile() throws Exception {
SearchFilter filter = new SearchFilter();
- File jsonRoleFile = new File(importRoleTestFilePath);
- InputStream uploadedInputStream = new FileInputStream(jsonRoleFile);
- FormDataContentDisposition fileDetail = FormDataContentDisposition.name("file").fileName(jsonRoleFile.getName()).size(uploadedInputStream.toString().length()).build();
- boolean updateIfExists = false;
- boolean createNonExistUserGroupRole = false;
+ File jsonRoleFile = new File(importRoleTestFilePath);
+ InputStream uploadedInputStream = new FileInputStream(jsonRoleFile);
+ FormDataContentDisposition fileDetail = FormDataContentDisposition.name("file").fileName(jsonRoleFile.getName()).size(uploadedInputStream.toString().length()).build();
+ boolean updateIfExists = false;
+ boolean createNonExistUserGroupRole = false;
Mockito.when(searchUtil.getSearchFilter(request, roleService.sortFields)).thenReturn(filter);
Mockito.when(roleStore.getRoleNames(Mockito.any(SearchFilter.class))).thenReturn(roleList);
Mockito.when(roleStore.createRole(Mockito.any(RangerRole.class), eq(createNonExistUserGroupRole))).thenReturn(rangerRole);
RESTResponse resp = roleRest.importRolesFromFile(request, uploadedInputStream, fileDetail, updateIfExists, createNonExistUserGroupRole);
- Assert.assertNotNull(resp);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, resp.getStatusCode());
- Assert.assertEquals("Total Role Created = 6 , Total Role Unchanged = 1", resp.getMsgDesc());
+ Assertions.assertNotNull(resp);
+ Assertions.assertEquals(resp.getStatusCode(), RESTResponse.STATUS_SUCCESS);
+ Assertions.assertEquals(resp.getMsgDesc(), "Total Role Created = 6 , Total Role Unchanged = 1");
}
// import role with updateIfExists=false and createNonExistUserGroupRole=true
@@ -1120,20 +1156,20 @@ public void test20bimportRolesFromFile() throws Exception {
SearchFilter filter = new SearchFilter();
- File jsonRoleFile = new File(importRoleTestFilePath);
- InputStream uploadedInputStream = new FileInputStream(jsonRoleFile);
- FormDataContentDisposition fileDetail = FormDataContentDisposition.name("file").fileName(jsonRoleFile.getName()).size(uploadedInputStream.toString().length()).build();
- boolean updateIfExists = false;
- boolean createNonExistUserGroupRole = true;
+ File jsonRoleFile = new File(importRoleTestFilePath);
+ InputStream uploadedInputStream = new FileInputStream(jsonRoleFile);
+ FormDataContentDisposition fileDetail = FormDataContentDisposition.name("file").fileName(jsonRoleFile.getName()).size(uploadedInputStream.toString().length()).build();
+ boolean updateIfExists = false;
+ boolean createNonExistUserGroupRole = true;
Mockito.when(searchUtil.getSearchFilter(request, roleService.sortFields)).thenReturn(filter);
Mockito.when(roleStore.getRoleNames(Mockito.any(SearchFilter.class))).thenReturn(roleList);
Mockito.when(roleStore.createRole(Mockito.any(RangerRole.class), eq(createNonExistUserGroupRole))).thenReturn(rangerRole);
RESTResponse resp = roleRest.importRolesFromFile(request, uploadedInputStream, fileDetail, updateIfExists, createNonExistUserGroupRole);
- Assert.assertNotNull(resp);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, resp.getStatusCode());
- Assert.assertEquals("Total Role Created = 6 , Total Role Unchanged = 1", resp.getMsgDesc());
+ Assertions.assertNotNull(resp);
+ Assertions.assertEquals(resp.getStatusCode(), RESTResponse.STATUS_SUCCESS);
+ Assertions.assertEquals(resp.getMsgDesc(), "Total Role Created = 6 , Total Role Unchanged = 1");
}
// import role with updateIfExists=true and createNonExistUserGroupRole=true
@@ -1147,11 +1183,11 @@ public void test20cimportRolesFromFileWithUpdate() throws Exception {
SearchFilter filter = new SearchFilter();
- File jsonRoleFile = new File(importRoleTestFilePath);
- InputStream uploadedInputStream = new FileInputStream(jsonRoleFile);
- FormDataContentDisposition fileDetail = FormDataContentDisposition.name("file").fileName(jsonRoleFile.getName()).size(uploadedInputStream.toString().length()).build();
- boolean updateIfExists = true;
- boolean createNonExistUserGroupRole = true;
+ File jsonRoleFile = new File(importRoleTestFilePath);
+ InputStream uploadedInputStream = new FileInputStream(jsonRoleFile);
+ FormDataContentDisposition fileDetail = FormDataContentDisposition.name("file").fileName(jsonRoleFile.getName()).size(uploadedInputStream.toString().length()).build();
+ boolean updateIfExists = true;
+ boolean createNonExistUserGroupRole = true;
Mockito.when(searchUtil.getSearchFilter(request, roleService.sortFields)).thenReturn(filter);
Mockito.when(roleStore.getRoleNames(Mockito.any(SearchFilter.class))).thenReturn(roleList);
@@ -1159,62 +1195,67 @@ public void test20cimportRolesFromFileWithUpdate() throws Exception {
Mockito.when(roleStore.createRole(Mockito.any(RangerRole.class), eq(createNonExistUserGroupRole))).thenReturn(rangerRole);
RESTResponse resp = roleRest.importRolesFromFile(request, uploadedInputStream, fileDetail, updateIfExists, createNonExistUserGroupRole);
- Assert.assertNotNull(resp);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, resp.getStatusCode());
- Assert.assertEquals("Total Role Created = 6 , Total Role Updated = 1 , Total Role Unchanged = 0", resp.getMsgDesc());
+ Assertions.assertNotNull(resp);
+ Assertions.assertEquals(resp.getStatusCode(), RESTResponse.STATUS_SUCCESS);
+ Assertions.assertEquals(resp.getMsgDesc(), "Total Role Created = 6 , Total Role Updated = 1 , Total Role Unchanged = 0");
}
// import role throws exceptions
@SuppressWarnings("unchecked")
- @Test(expected = Throwable.class)
+ @Test
public void test20dimportRolesFromFileWithUpdate() throws Exception {
- HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Assertions.assertThrows(Throwable.class, () -> {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
- File jsonRoleFile = new File(importRoleTestFilePath);
- InputStream uploadedInputStream = new FileInputStream(jsonRoleFile);
- FormDataContentDisposition fileDetail = FormDataContentDisposition.name("file").fileName(jsonRoleFile.getName()).size(uploadedInputStream.toString().length()).build();
- boolean updateIfExists = false;
- boolean createNonExistUserGroupRole = false;
+ File jsonRoleFile = new File(importRoleTestFilePath);
+ InputStream uploadedInputStream = new FileInputStream(jsonRoleFile);
+ FormDataContentDisposition fileDetail = FormDataContentDisposition.name("file").fileName(jsonRoleFile.getName()).size(uploadedInputStream.toString().length()).build();
+ boolean updateIfExists = false;
+ boolean createNonExistUserGroupRole = false;
- Mockito.when(roleStore.getRoleNames(Mockito.any(SearchFilter.class))).thenThrow(new Throwable());
+ Mockito.when(roleStore.getRoleNames(Mockito.any(SearchFilter.class))).thenThrow(new Throwable());
- Assert.assertThrows(Throwable.class, () -> roleRest.importRolesFromFile(request, uploadedInputStream, fileDetail, updateIfExists, createNonExistUserGroupRole));
- Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+ roleRest.importRolesFromFile(request, uploadedInputStream, fileDetail, updateIfExists, createNonExistUserGroupRole);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test21deleteRoleWithinPolicy() {
- RangerRole rangerRole = createRole();
- rangerPolicy(rangerRole);
- try {
- Mockito.doThrow(new Throwable()).when(roleStore).deleteRole(Mockito.anyLong());
- } catch (Throwable e) {
- throw new RuntimeException(e);
- }
-
- try {
- Assert.assertThrows(Throwable.class, () -> roleRest.deleteRole(rangerRole.getId()));
- Mockito.verify(restErrorUtil, Mockito.times(1)).createRESTException(Mockito.anyString());
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ Assertions.assertThrows(Throwable.class, () -> {
+ RangerRole rangerRole = createRole();
+ rangerPolicy(rangerRole);
+ try {
+ Mockito.doThrow(new Throwable()).when(roleStore).deleteRole(Mockito.anyLong());
+ } catch (Throwable e) {
+ throw new RuntimeException(e);
+ }
+ try {
+ roleRest.deleteRole(rangerRole.getId());
+ Mockito.verify(restErrorUtil, Mockito.times(1)).createRESTException(Mockito.anyString());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
}
- @Test(expected = Throwable.class)
+ @Test
public void test22deleteRoleWithValidationError() {
- RangerRole rangerRole = createRole();
- try {
- Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenThrow(new Exception());
- } catch (Throwable e) {
- throw new RuntimeException(e);
- }
-
- try {
- Assert.assertThrows(Throwable.class, () -> roleRest.deleteRole(rangerRole.getId()));
- Mockito.verify(restErrorUtil, Mockito.times(1)).createRESTException(Mockito.anyString());
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ Assertions.assertThrows(Throwable.class, () -> {
+ RangerRole rangerRole = createRole();
+ try {
+ Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenThrow(new Exception());
+ } catch (Throwable e) {
+ throw new RuntimeException(e);
+ }
+
+ try {
+ roleRest.deleteRole(rangerRole.getId());
+ Mockito.verify(restErrorUtil, Mockito.times(1)).createRESTException(Mockito.anyString());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
}
private RangerRole createRole() {
@@ -1273,7 +1314,7 @@ private RangerRole createRoleOld() {
private VXUser createVXUser() {
VXUser testVXUser = new VXUser();
- Collection<String> c = new ArrayList<>();
+ Collection<String> c = new ArrayList<String>();
testVXUser.setId(userId);
testVXUser.setCreateDate(new Date());
testVXUser.setUpdateDate(new Date());
@@ -1294,7 +1335,7 @@ private VXUser createVXUser() {
}
private List<XXRoleRefGroup> createXXRoleRefGroupList() {
- List<XXRoleRefGroup> xxRoleRefGroupList = new ArrayList<>();
+ List<XXRoleRefGroup> xxRoleRefGroupList = new ArrayList<XXRoleRefGroup>();
XXRoleRefGroup xxRoleRefGroup1 = new XXRoleRefGroup();
xxRoleRefGroup1.setRoleId(roleId);
xxRoleRefGroupList.add(xxRoleRefGroup1);
@@ -1302,7 +1343,7 @@ private List<XXRoleRefGroup> createXXRoleRefGroupList() {
}
private List<XXRoleRefUser> createXXRoleRefUserList() {
- List<XXRoleRefUser> xxRoleRefUserList = new ArrayList<>();
+ List<XXRoleRefUser> xxRoleRefUserList = new ArrayList<XXRoleRefUser>();
XXRoleRefUser xxRoleRefUser1 = new XXRoleRefUser();
xxRoleRefUser1.setRoleId(roleId);
xxRoleRefUserList.add(xxRoleRefUser1);
@@ -1310,7 +1351,7 @@ private List<XXRoleRefUser> createXXRoleRefUserList() {
}
private List<String> createRoleList() {
- List<String> roleList = new ArrayList<>();
+ List<String> roleList = new ArrayList<String>();
roleList.add("admin");
roleList.add("user");
return roleList;
@@ -1386,4 +1427,222 @@ private static RangerPolicy getRangerPolicy(List<RangerPolicyItem> policyItems,
policy.setService("HDFS_1");
return policy;
}
+
+ @Test
+ public void test23CreateRoleWithNullUsers() {
+ boolean createNonExistUserGroup = true;
+ RangerRole rangerRole = createRole();
+ rangerRole.setUsers(null); // Set users to null
+
+ Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenReturn(Mockito.mock(RangerRoleValidator.class));
+ Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
+
+ try {
+ Mockito.when(roleStore.createRole(Mockito.any(RangerRole.class), eq(createNonExistUserGroup))).thenReturn(rangerRole);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ RangerRole createdRole = roleRest.createRole("admin", rangerRole, createNonExistUserGroup);
+ Assertions.assertNotNull(createdRole);
+ Assertions.assertEquals(createdRole.getName(), rangerRole.getName());
+ }
+
+ @Test
+ public void test24CreateRoleWithEmptyUsers() {
+ boolean createNonExistUserGroup = true;
+ RangerRole rangerRole = createRole();
+ rangerRole.setUsers(new ArrayList<>()); // Set users to empty list
+
+ Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenReturn(Mockito.mock(RangerRoleValidator.class));
+ Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
+
+ try {
+ Mockito.when(roleStore.createRole(Mockito.any(RangerRole.class), eq(createNonExistUserGroup))).thenReturn(rangerRole);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ RangerRole createdRole = roleRest.createRole("admin", rangerRole, createNonExistUserGroup);
+ Assertions.assertNotNull(createdRole);
+ Assertions.assertEquals(createdRole.getName(), rangerRole.getName());
+ }
+
+ @Test
+ public void test25UpdateRoleWithConcurrentModification() {
+ Boolean createNonExistUserGroup = Boolean.TRUE;
+ RangerRole rangerRole = createRole();
+ RangerRole rangerRoleOld = createRoleOld();
+ rangerRoleOld.setVersion(1L);
+ rangerRole.setVersion(2L); // Different version - should indicate concurrent modification
+
+ Mockito.when(validatorFactory.getRangerRoleValidator(roleStore)).thenReturn(Mockito.mock(RangerRoleValidator.class));
+ XXRoleDao xxRoleDao = Mockito.mock(XXRoleDao.class);
+ Mockito.when(daoMgr.getXXRole()).thenReturn(xxRoleDao);
+
+ try {
+ Mockito.when(roleStore.getRole(Mockito.anyLong())).thenReturn(rangerRoleOld);
+ Mockito.when(roleStore.updateRole(Mockito.any(RangerRole.class), Mockito.anyBoolean())).thenReturn(rangerRole);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ RangerRole updatedRole = roleRest.updateRole(roleId, rangerRole, eq(createNonExistUserGroup));
+ Assertions.assertNotNull(updatedRole);
+ }
+
+ @Test
+ public void test26GetRoleByNameNotFound() throws Exception {
+ String roleName = "nonexistent-role";
+ Set<String> groups = new HashSet<>(Arrays.asList("group1", "group2"));
+ Mockito.when(userMgr.getGroupsForUser(Mockito.anyString())).thenReturn(groups);
+ Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
+ Mockito.when(roleStore.getRole(Mockito.anyString())).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ roleRest.getRole("admin", adminLoginID, roleName);
+ });
+
+ Mockito.verify(roleStore, Mockito.times(1)).getRole(Mockito.anyString());
+ }
+
+ @Test
+ public void test27AddUsersAndGroupsWithDuplicates() {
+ RangerRole rangerRole = createRoleWithUsersAndGroups();
+ List<String> users = new ArrayList<>(Arrays.asList("test-role", "admin")); // Duplicate users
+ List<String> groups = new ArrayList<>(Arrays.asList("test-group", "admin")); // Duplicate groups
+ Boolean isAdmin = true;
+
+ Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
+
+ try {
+ Mockito.when(roleStore.getRole(Mockito.anyLong())).thenReturn(rangerRole);
+ Mockito.when(roleStore.updateRole(Mockito.any(RangerRole.class), Mockito.anyBoolean())).then(AdditionalAnswers.returnsFirstArg());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ RangerRole returnedRole = roleRest.addUsersAndGroups(roleId, users, groups, isAdmin);
+ Assertions.assertNotNull(returnedRole);
+ }
+
+ @Test
+ public void test28RemoveUsersAndGroupsNonExistent() {
+ RangerRole rangerRole = createRoleWithUsersAndGroups();
+ List<String> users = new ArrayList<>(Arrays.asList("non-existent-user"));
+ List<String> groups = new ArrayList<>(Arrays.asList("non-existent-group"));
+
+ Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
+
+ try {
+ Mockito.when(roleStore.getRole(Mockito.anyLong())).thenReturn(rangerRole);
+ Mockito.when(roleStore.updateRole(Mockito.any(RangerRole.class), Mockito.anyBoolean())).then(AdditionalAnswers.returnsFirstArg());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ RangerRole returnedRole = roleRest.removeUsersAndGroups(roleId, users, groups);
+ Assertions.assertNotNull(returnedRole);
+ }
+
+ @Test
+ public void test29GrantRoleWithEmptyTargetRoles() {
+ RangerRole rangerRole = createRole();
+ String serviceName = "serviceName";
+ GrantRevokeRoleRequest grantRevokeRoleRequest = createGrantRevokeRoleRequest();
+ grantRevokeRoleRequest.setTargetRoles(new HashSet<>());
+
+ RESTResponse resp = roleRest.grantRole(serviceName, grantRevokeRoleRequest, Mockito.mock(HttpServletRequest.class));
+ Assertions.assertNotNull(resp);
+ }
+
+ @Test
+ public void test30RevokeRoleWithNullGrantor() {
+ RangerRole rangerRole = createRole();
+ String serviceName = "serviceName";
+ GrantRevokeRoleRequest grantRevokeRoleRequest = createGrantRevokeRoleRequest();
+ grantRevokeRoleRequest.setGrantor(null); // Null grantor
+
+ Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
+
+ try {
+ Mockito.when(roleStore.getRole(Mockito.anyString())).thenReturn(rangerRole);
+ Mockito.when(roleStore.updateRole(Mockito.any(RangerRole.class), Mockito.anyBoolean())).then(AdditionalAnswers.returnsFirstArg());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ RESTResponse resp = roleRest.revokeRole(serviceName, grantRevokeRoleRequest, Mockito.mock(HttpServletRequest.class));
+ Assertions.assertNotNull(resp);
+ }
+
+ @Test
+ public void test31GetUserRolesWithNullGroups() {
+ Set<RangerRole> rangerRoles = new HashSet<>();
+ RangerRole rangerRole = createRole();
+ rangerRoles.add(rangerRole);
+ List<XXRoleRefGroup> xxRoleRefGroupList = createXXRoleRefGroupList();
+ List<XXRoleRefUser> xxRoleRefRoleList = createXXRoleRefUserList();
+
+ Mockito.when(xUserService.getXUserByUserName(Mockito.anyString())).thenReturn(createVXUser());
+ Mockito.when(userMgr.getGroupsForUser(Mockito.anyString())).thenReturn(null); // Null groups
+ Mockito.when(roleRefUpdater.getRangerDaoManager().getXXRoleRefUser().findByUserName(adminLoginID)).thenReturn(xxRoleRefRoleList);
+ Mockito.when(roleRefUpdater.getRangerDaoManager().getXXRoleRefGroup().findByGroupName(adminLoginID)).thenReturn(xxRoleRefGroupList);
+
+ try {
+ Mockito.when(roleStore.getRoleNames(Mockito.anyString(), Mockito.any())).thenReturn(rangerRoles);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ List<String> returnedRoles = roleRest.getUserRoles(adminLoginID, Mockito.mock(HttpServletRequest.class));
+ Assertions.assertNotNull(returnedRoles);
+ }
+
+ @Test
+ public void test32ImportRolesWithInvalidJSON() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ String invalidJson = "{ invalid json content }";
+ InputStream uploadedInputStream = new java.io.ByteArrayInputStream(invalidJson.getBytes());
+ FormDataContentDisposition fileDetail = FormDataContentDisposition.name("file").fileName("invalid.json").build();
+ boolean updateIfExists = false;
+ boolean createNonExistUserGroupRole = false;
+
+ Assertions.assertThrows(Throwable.class, () -> {
+ roleRest.importRolesFromFile(request, uploadedInputStream, fileDetail, updateIfExists, createNonExistUserGroupRole);
+ });
+ }
+
+ @Test
+ public void test33GetRangerRolesIfUpdatedWithNullService() throws Exception {
+ String serviceName = null;
+ String pluginId = "pluginId";
+ String clusterName = "";
+ String pluginCapabilities = "";
+
+ Mockito.doNothing().when(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+
+ RangerRoles result = roleRest.getRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
+ Assertions.assertNull(result);
+ Mockito.verify(bizUtil).failUnauthenticatedDownloadIfNotAllowed();
+ Mockito.verify(serviceUtil).isValidService(Mockito.isNull(), Mockito.any(HttpServletRequest.class));
+ }
+
+ @Test
+ public void test34GetSecureRangerRolesIfUpdatedWithInvalidService() {
+ String serviceName = "invalid-service";
+ String pluginId = "pluginId";
+ String clusterName = "";
+ String pluginCapabilities = "";
+
+ Mockito.when(serviceUtil.isValidService(Mockito.anyString(), Mockito.any(HttpServletRequest.class))).thenReturn(true);
+ Mockito.when(daoMgr.getXXService().findByName(Mockito.anyString())).thenReturn(null); // Service not found
+ Mockito.when(bizUtil.isAdmin()).thenReturn(false);
+
+ Assertions.assertThrows(Throwable.class, () -> {
+ roleRest.getSecureRangerRolesIfUpdated(serviceName, -1L, 0L, pluginId, clusterName, pluginCapabilities, Mockito.mock(HttpServletRequest.class));
+ });
+ }
}
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestSecurityZoneREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestSecurityZoneREST.java
index 21f161f33..a4aa9c92c 100644
--- a/security-admin/src/test/java/org/apache/ranger/rest/TestSecurityZoneREST.java
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestSecurityZoneREST.java
@@ -1,5 +1,4 @@
/*
-
* 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.
@@ -18,9 +17,13 @@
package org.apache.ranger.rest;
import org.apache.ranger.biz.RangerBizUtil;
+import org.apache.ranger.biz.RangerPolicyAdmin;
import org.apache.ranger.biz.SecurityZoneDBStore;
import org.apache.ranger.biz.ServiceDBStore;
+import org.apache.ranger.biz.ServiceMgr;
+import org.apache.ranger.common.MessageEnums;
import org.apache.ranger.common.RESTErrorUtil;
+import org.apache.ranger.common.RangerConstants;
import org.apache.ranger.common.RangerSearchUtil;
import org.apache.ranger.common.RangerValidatorFactory;
import org.apache.ranger.db.RangerDaoManager;
@@ -30,39 +33,66 @@
import org.apache.ranger.entity.XXServiceDef;
import org.apache.ranger.plugin.model.RangerSecurityZone;
import org.apache.ranger.plugin.model.RangerSecurityZone.RangerSecurityZoneService;
+import org.apache.ranger.plugin.model.RangerSecurityZone.SecurityZoneSummary;
+import org.apache.ranger.plugin.model.RangerSecurityZoneHeaderInfo;
+import org.apache.ranger.plugin.model.RangerSecurityZoneV2;
+import org.apache.ranger.plugin.model.RangerSecurityZoneV2.RangerSecurityZoneChangeRequest;
import org.apache.ranger.plugin.model.validation.RangerSecurityZoneValidator;
import org.apache.ranger.plugin.model.validation.RangerValidator;
+import org.apache.ranger.plugin.store.PList;
import org.apache.ranger.plugin.util.SearchFilter;
import org.apache.ranger.service.RangerSecurityZoneServiceService;
import org.apache.ranger.view.RangerSecurityZoneList;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
+import javax.persistence.OptimisticLockException;
import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.WebApplicationException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyMap;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.Silent.class)
+/**
+* @generated by Cursor
+* @description <Unit Test for TestSecurityZoneREST class>
+*/
+@ExtendWith(MockitoExtension.class)
+@TestMethodOrder(MethodOrderer.MethodName.class)
public class TestSecurityZoneREST {
- @Rule
- public ExpectedException thrown = ExpectedException.none();
@InjectMocks
SecurityZoneREST securityZoneREST = new SecurityZoneREST();
@Mock
@@ -85,6 +115,10 @@ public class TestSecurityZoneREST {
RangerDaoManager daoManager;
@Mock
XXServiceDef xServiceDef;
+ @Mock
+ ServiceREST serviceRest;
+ @Mock
+ ServiceMgr serviceMgr;
@Test
public void testCreateSecurityZone() throws Exception {
@@ -102,9 +136,83 @@ public void testCreateSecurityZone() throws Exception {
when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
doNothing().when(validator).validate(rangerSecurityZone, RangerValidator.Action.CREATE);
when(securityZoneStore.createSecurityZone(rangerSecurityZone)).thenReturn(rangerSecurityZone);
+
RangerSecurityZone createdRangerSecurityZone = securityZoneREST.createSecurityZone(rangerSecurityZone);
- assertEquals(createdRangerSecurityZone.getName(), rangerSecurityZone.getName());
+ Assertions.assertEquals(createdRangerSecurityZone.getName(), rangerSecurityZone.getName());
verify(validator, times(1)).validate(rangerSecurityZone, RangerValidator.Action.CREATE);
+ verify(securityZoneStore, times(1)).createSecurityZone(rangerSecurityZone);
+ }
+
+ @Test
+ public void createSecurityZone_AdminAccessDenied() throws Exception {
+ RangerSecurityZone rangerSecurityZone = createRangerSecurityZone();
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ when(rangerBizUtil.isAdmin()).thenReturn(false);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("nonAdminUser");
+
+ when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class))).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.createSecurityZone(rangerSecurityZone);
+ });
+
+ verify(validator, never()).validate(rangerSecurityZone, RangerValidator.Action.CREATE);
+ verify(securityZoneStore, never()).createSecurityZone(rangerSecurityZone);
+ verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class));
+ }
+
+ @Test
+ public void testCreateSecurityZoneOptimisticLockException() throws Exception {
+ RangerSecurityZone rangerSecurityZone = createRangerSecurityZone();
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(daoManager.getXXService()).thenReturn(xServiceDao);
+ when(xServiceDao.findByName("test_service_1")).thenReturn(xService);
+
+ when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ doNothing().when(validator).validate(rangerSecurityZone, RangerValidator.Action.CREATE);
+
+ when(securityZoneStore.createSecurityZone(rangerSecurityZone)).thenThrow(new OptimisticLockException());
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.createSecurityZone(rangerSecurityZone);
+ });
+
+ verify(validator, times(1)).validate(rangerSecurityZone, RangerValidator.Action.CREATE);
+ verify(securityZoneStore).createSecurityZone(rangerSecurityZone);
+ verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void testCreateSecurityZoneException() throws Exception {
+ RangerSecurityZone rangerSecurityZone = createRangerSecurityZone();
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(daoManager.getXXService()).thenReturn(xServiceDao);
+ when(xServiceDao.findByName("test_service_1")).thenReturn(xService);
+
+ when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenThrow(new RuntimeException("General exception"));
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.createSecurityZone(rangerSecurityZone);
+ });
+
+ verify(validator, never()).validate(rangerSecurityZone, RangerValidator.Action.CREATE);
+ verify(securityZoneStore, never()).createSecurityZone(rangerSecurityZone);
}
@Test
@@ -118,47 +226,92 @@ public void testUpdateSecurityZone() throws Exception {
when(rangerBizUtil.isAdmin()).thenReturn(true);
when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
- when(daoManager.getXXService()).thenReturn(xServiceDao);
- when(xServiceDao.findByName("test_service_1")).thenReturn(xService);
-
- when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
- when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
-
doNothing().when(validator).validate(rangerSecurityZoneToUpdate, RangerValidator.Action.UPDATE);
when(securityZoneStore.updateSecurityZoneById(rangerSecurityZoneToUpdate)).thenReturn(rangerSecurityZoneToUpdate);
RangerSecurityZone updatedRangerSecurityZone = securityZoneREST.updateSecurityZone(securityZoneId, rangerSecurityZoneToUpdate);
- assertEquals(rangerSecurityZoneToUpdate.getId(), updatedRangerSecurityZone.getId());
+ Assertions.assertEquals(rangerSecurityZoneToUpdate.getId(), updatedRangerSecurityZone.getId());
verify(validator, times(1)).validate(rangerSecurityZoneToUpdate, RangerValidator.Action.UPDATE);
}
@Test
public void testUpdateSecurityZoneWithMisMatchId() throws Exception {
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ RangerSecurityZone rangerSecurityZoneToUpdate = createRangerSecurityZone();
+ Long securityZoneId = 2L;
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+
+ rangerSecurityZoneToUpdate.setId(securityZoneId);
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+ RangerSecurityZone updatedRangerSecurityZone = securityZoneREST.updateSecurityZone(9L, rangerSecurityZoneToUpdate);
+ Assertions.assertEquals(rangerSecurityZoneToUpdate.getId(), updatedRangerSecurityZone.getId());
+ verify(validator, times(1)).validate(rangerSecurityZoneToUpdate, RangerValidator.Action.UPDATE);
+ });
+ }
+
+ @Test
+ public void testUpdateSecurityZoneOptimisticLockException() throws Exception {
RangerSecurityZone rangerSecurityZoneToUpdate = createRangerSecurityZone();
Long securityZoneId = 2L;
- XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
XXService xService = Mockito.mock(XXService.class);
-
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
rangerSecurityZoneToUpdate.setId(securityZoneId);
when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
- when(daoManager.getXXService()).thenReturn(xServiceDao);
- when(xServiceDao.findByName("test_service_1")).thenReturn(xService);
+ doNothing().when(validator).validate(rangerSecurityZoneToUpdate, RangerValidator.Action.UPDATE);
+ when(securityZoneStore.updateSecurityZoneById(rangerSecurityZoneToUpdate)).thenThrow(new OptimisticLockException());
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
- when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
- when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+ WebApplicationException thrown = Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.updateSecurityZone(securityZoneId, rangerSecurityZoneToUpdate);
+ });
+
+ verify(validator, times(1)).validate(rangerSecurityZoneToUpdate, RangerValidator.Action.UPDATE);
+ verify(securityZoneStore).updateSecurityZoneById(rangerSecurityZoneToUpdate);
+ verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+ @Test
+ public void testUpdateSecurityZoneException() throws Exception {
+ RangerSecurityZone rangerSecurityZoneToUpdate = createRangerSecurityZone();
+ Long securityZoneId = 2L;
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ rangerSecurityZoneToUpdate.setId(securityZoneId);
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+
doNothing().when(validator).validate(rangerSecurityZoneToUpdate, RangerValidator.Action.UPDATE);
- when(securityZoneStore.updateSecurityZoneById(rangerSecurityZoneToUpdate)).thenReturn(rangerSecurityZoneToUpdate);
- when(restErrorUtil.createRESTException(Mockito.anyString())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
- RangerSecurityZone updatedRangerSecurityZone = securityZoneREST.updateSecurityZone(9L, rangerSecurityZoneToUpdate);
- assertEquals(rangerSecurityZoneToUpdate.getId(), updatedRangerSecurityZone.getId());
+ when(securityZoneStore.updateSecurityZoneById(rangerSecurityZoneToUpdate)).thenThrow(new RuntimeException("General exception"));
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.updateSecurityZone(securityZoneId, rangerSecurityZoneToUpdate);
+ });
+
verify(validator, times(1)).validate(rangerSecurityZoneToUpdate, RangerValidator.Action.UPDATE);
+ verify(securityZoneStore).updateSecurityZoneById(rangerSecurityZoneToUpdate);
+ verify(restErrorUtil).createRESTException(Mockito.anyString());
}
- @Test(expected = WebApplicationException.class)
+ @Test
+ public void testUpdateUnzonedSecurityZone() throws Exception {
+ RangerSecurityZone rangerSecurityZone = createRangerSecurityZone();
+ when(restErrorUtil.createRESTException("Cannot update unzoned zone")).thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.updateSecurityZone(RangerSecurityZone.RANGER_UNZONED_SECURITY_ZONE_ID, rangerSecurityZone);
+ });
+ verify(restErrorUtil).createRESTException("Cannot update unzoned zone");
+ }
+
+ @Test
public void testGetSecurityZoneById() throws Exception {
RangerSecurityZone securityZone = createRangerSecurityZone();
Long securityZoneId = 2L;
@@ -166,17 +319,75 @@ public void testGetSecurityZoneById() throws Exception {
when(securityZoneStore.getSecurityZone(securityZoneId)).thenReturn(securityZone);
when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
RangerSecurityZone rangerSecurityZone = securityZoneREST.getSecurityZone(securityZoneId);
- assertEquals(securityZoneId, rangerSecurityZone.getId());
+ Assertions.assertEquals(securityZoneId, rangerSecurityZone.getId());
verify(securityZoneStore, times(1)).getSecurityZone(securityZoneId);
//No access
- when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(false);
- when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenReturn(new WebApplicationException());
- securityZoneREST.getSecurityZone(securityZoneId);
- verify(securityZoneStore, times(0)).getSecurityZone(securityZoneId);
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(false);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenReturn(new WebApplicationException());
+ securityZoneREST.getSecurityZone(securityZoneId);
+ verify(securityZoneStore, times(0)).getSecurityZone(securityZoneId);
+ });
+ }
+
+ @Test
+ public void getSecurityZoneById_NoModuleAccess() throws Exception {
+ Long zoneId = 1L;
+
+ when(rangerBizUtil.hasModuleAccess(RangerConstants.MODULE_SECURITY_ZONE)).thenReturn(false);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class))).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getSecurityZone(zoneId);
+ });
+
+ verify(securityZoneStore, never()).getSecurityZone(anyLong());
+ verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class));
+ }
+
+ @Test
+ public void testGetSecurityZoneByIdWithException() throws Exception {
+ Long zoneId = 2L;
+
+ when(rangerBizUtil.hasModuleAccess(RangerConstants.MODULE_SECURITY_ZONE)).thenReturn(true);
+ when(securityZoneStore.getSecurityZone(zoneId)).thenThrow(new RuntimeException("Database error"));
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getSecurityZone(zoneId);
+ });
+
+ verify(securityZoneStore).getSecurityZone(zoneId);
+ verify(restErrorUtil).createRESTException(Mockito.anyString());
}
- @Test(expected = WebApplicationException.class)
+ @Test
+ public void testGetSecurityZoneByIdWithWebException() throws Exception {
+ Long zoneId = 2L;
+
+ when(rangerBizUtil.hasModuleAccess(RangerConstants.MODULE_SECURITY_ZONE)).thenReturn(true);
+ when(securityZoneStore.getSecurityZone(zoneId)).thenThrow(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getSecurityZone(zoneId);
+ });
+
+ verify(securityZoneStore).getSecurityZone(zoneId);
+ verify(restErrorUtil, never()).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void testGetUnzonedSecurityZone() throws Exception {
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(restErrorUtil.createRESTException("Cannot access unzoned zone")).thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getSecurityZone(RangerSecurityZone.RANGER_UNZONED_SECURITY_ZONE_ID);
+ });
+ }
+
+ @Test
public void testGetSecurityZoneByName() throws Exception {
RangerSecurityZone securityZone = createRangerSecurityZone();
Long securityZoneId = 2L;
@@ -185,24 +396,68 @@ public void testGetSecurityZoneByName() throws Exception {
when(securityZoneStore.getSecurityZoneByName(securityZoneName)).thenReturn(securityZone);
when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
RangerSecurityZone rangerSecurityZone = securityZoneREST.getSecurityZone(securityZoneName);
- assertEquals(securityZoneName, rangerSecurityZone.getName());
+ Assertions.assertEquals(securityZoneName, rangerSecurityZone.getName());
verify(securityZoneStore, times(1)).getSecurityZoneByName(securityZoneName);
//No access
- when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(false);
- when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenReturn(new WebApplicationException());
- securityZoneREST.getSecurityZone(securityZoneName);
- verify(securityZoneStore, times(0)).getSecurityZoneByName(securityZoneName);
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(false);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenReturn(new WebApplicationException());
+ securityZoneREST.getSecurityZone(securityZoneName);
+ verify(securityZoneStore, times(0)).getSecurityZoneByName(securityZoneName);
+ });
}
- @Test(expected = WebApplicationException.class)
+ @Test
+ public void getSecurityZoneByName_NoModuleAccess() throws Exception {
+ String zoneName = "testZone";
+
+ when(rangerBizUtil.hasModuleAccess(RangerConstants.MODULE_SECURITY_ZONE)).thenReturn(false);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class))).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getSecurityZone(zoneName);
+ });
+
+ verify(securityZoneStore, never()).getSecurityZoneByName(anyString());
+ }
+
+ @Test
+ public void testGetSecurityZoneByNameWithException() throws Exception {
+ String zoneName = "testZone";
+
+ when(rangerBizUtil.hasModuleAccess(RangerConstants.MODULE_SECURITY_ZONE)).thenReturn(true);
+ when(securityZoneStore.getSecurityZoneByName(zoneName)).thenThrow(new RuntimeException("General exception"));
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getSecurityZone(zoneName);
+ });
+
+ verify(securityZoneStore).getSecurityZoneByName(zoneName);
+ verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void testGetSecurityZoneByNameWithWebException() throws Exception {
+ String zoneName = "testZone";
+
+ when(rangerBizUtil.hasModuleAccess(RangerConstants.MODULE_SECURITY_ZONE)).thenReturn(true);
+ when(securityZoneStore.getSecurityZoneByName(zoneName)).thenThrow(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getSecurityZone(zoneName);
+ });
+
+ verify(securityZoneStore).getSecurityZoneByName(zoneName);
+ }
+
+ @Test
public void testGetAllSecurityZone() throws Exception {
RangerSecurityZone securityZone = createRangerSecurityZone();
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
SearchFilter filter = new SearchFilter();
- when(
- searchUtil.getSearchFilter(request, securityZoneService.sortFields))
- .thenReturn(filter);
+ when(searchUtil.getSearchFilter(request, securityZoneService.sortFields)).thenReturn(filter);
Long securityZoneId = 2L;
securityZone.setId(securityZoneId);
List<RangerSecurityZone> zonesList = new ArrayList<>();
@@ -214,14 +469,64 @@ public void testGetAllSecurityZone() throws Exception {
when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
RangerSecurityZoneList returnedZonesList = securityZoneREST.getAllZones(request);
- assertEquals(returnedZonesList.getResultSize(), rangerZoneList.getList().size());
+ Assertions.assertEquals(returnedZonesList.getResultSize(), rangerZoneList.getList().size());
verify(securityZoneStore, times(1)).getSecurityZones(filter);
//No access
- when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(false);
- when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenReturn(new WebApplicationException());
- securityZoneREST.getAllZones(request);
- verify(securityZoneStore, times(0)).getSecurityZones(filter);
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(false);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenReturn(new WebApplicationException());
+ securityZoneREST.getAllZones(request);
+ verify(securityZoneStore, times(0)).getSecurityZones(filter);
+ });
+ }
+
+ @Test
+ public void testGetAllZonesWithException() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(searchUtil.getSearchFilter(request, securityZoneService.sortFields)).thenReturn(filter);
+ when(securityZoneStore.getSecurityZones(filter)).thenThrow(new RuntimeException("General exception"));
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getAllZones(request);
+ });
+
+ verify(securityZoneStore).getSecurityZones(filter);
+ verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void testGetAllZonesWithWebException() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(searchUtil.getSearchFilter(request, securityZoneService.sortFields)).thenReturn(filter);
+ when(securityZoneStore.getSecurityZones(filter)).thenThrow(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getAllZones(request);
+ });
+
+ verify(securityZoneStore).getSecurityZones(filter);
+ }
+
+ @Test
+ public void getAllZones_NoModuleAccess() throws Exception {
+ HttpServletRequest request = mock(HttpServletRequest.class);
+
+ when(rangerBizUtil.hasModuleAccess(RangerConstants.MODULE_SECURITY_ZONE)).thenReturn(false);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class))).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getAllZones(request);
+ });
+
+ verify(securityZoneStore, never()).getSecurityZones(any());
}
@Test
@@ -236,6 +541,69 @@ public void testDeleteSecurityZoneById() throws Exception {
verify(securityZoneStore, times(1)).deleteSecurityZoneById(securityZoneId);
}
+ @Test
+ public void testDeleteUnzonedSecurityZone() throws Exception {
+ when(restErrorUtil.createRESTException("Cannot delete unzoned zone")).thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.deleteSecurityZone(RangerSecurityZone.RANGER_UNZONED_SECURITY_ZONE_ID);
+ });
+ }
+
+ @Test
+ public void testDeleteSecurityZoneByIdOptimisticLockException() throws Exception {
+ Long zoneId = 2L;
+
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ doNothing().when(validator).validate(zoneId, RangerValidator.Action.DELETE);
+ Mockito.doThrow(new OptimisticLockException()).when(securityZoneStore).deleteSecurityZoneById(zoneId);
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.deleteSecurityZone(zoneId);
+ });
+
+ verify(validator).validate(zoneId, RangerValidator.Action.DELETE);
+ verify(securityZoneStore).deleteSecurityZoneById(zoneId);
+ verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void testDeleteSecurityZoneByIdException() throws Exception {
+ Long zoneId = 2L;
+
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ doNothing().when(validator).validate(zoneId, RangerValidator.Action.DELETE);
+ Mockito.doThrow(new RuntimeException("General exception")).when(securityZoneStore).deleteSecurityZoneById(zoneId);
+ when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(), Mockito.nullable(Long.class), Mockito.nullable(String.class), Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.deleteSecurityZone(zoneId);
+ });
+
+ verify(validator).validate(zoneId, RangerValidator.Action.DELETE);
+ verify(securityZoneStore).deleteSecurityZoneById(zoneId);
+ verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any(), Mockito.nullable(Long.class), Mockito.nullable(String.class), Mockito.anyString());
+ }
+
+ @Test
+ public void deleteSecurityZoneById_AdminAccessDenied() throws Exception {
+ Long zoneId = 2L;
+
+ when(rangerBizUtil.isAdmin()).thenReturn(false);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("nonAdminUser");
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.deleteSecurityZone(zoneId);
+ });
+
+ verify(validator, never()).validate(anyLong(), any());
+ verify(securityZoneStore, never()).deleteSecurityZoneById(anyLong());
+ }
+
@Test
public void testDeleteSecurityZoneByName() throws Exception {
RangerSecurityZone securityZone = createRangerSecurityZone();
@@ -249,6 +617,679 @@ public void testDeleteSecurityZoneByName() throws Exception {
verify(securityZoneStore, times(1)).deleteSecurityZoneByName(securityZoneName);
}
+ @Test
+ public void deleteSecurityZoneByName_AdminAccessDenied() throws Exception {
+ String zoneName = "testZoneToDelete";
+
+ when(rangerBizUtil.isAdmin()).thenReturn(false);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("nonAdminUser");
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.deleteSecurityZone(zoneName);
+ });
+
+ verify(validator, never()).validate(anyString(), any());
+ verify(securityZoneStore, never()).deleteSecurityZoneByName(anyString());
+ }
+
+ @Test
+ public void deleteSecurityZoneByNameOptimisticLockException() throws Exception {
+ String zoneName = "testZoneToDelete";
+
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ Mockito.doNothing().when(validator).validate(Mockito.eq(zoneName), Mockito.eq(RangerValidator.Action.DELETE));
+ Mockito.doThrow(new OptimisticLockException()).when(securityZoneStore).deleteSecurityZoneByName(zoneName);
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.deleteSecurityZone(zoneName);
+ });
+
+ verify(validator, times(1)).validate(zoneName, RangerValidator.Action.DELETE);
+ verify(securityZoneStore, times(1)).deleteSecurityZoneByName(zoneName);
+ }
+
+ @Test
+ public void deleteSecurityZoneByNameException() throws Exception {
+ String zoneName = "testZoneToDelete";
+
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ Mockito.doNothing().when(validator).validate(Mockito.eq(zoneName), Mockito.eq(RangerValidator.Action.DELETE));
+ Mockito.doThrow(new RuntimeException("General exception")).when(securityZoneStore).deleteSecurityZoneByName(zoneName);
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.deleteSecurityZone(zoneName);
+ });
+
+ verify(validator, times(1)).validate(zoneName, RangerValidator.Action.DELETE);
+ verify(securityZoneStore, times(1)).deleteSecurityZoneByName(zoneName);
+ verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void testGetZoneNamesForResource() throws Exception {
+ String serviceName = "test_service";
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicyAdmin policyAdmin = Mockito.mock(RangerPolicyAdmin.class);
+ Collection<String> expectedZoneNames = new HashSet<>(Arrays.asList("zoneA", "zoneB"));
+ SearchFilter filter = Mockito.mock(SearchFilter.class);
+
+ Map<String, String> resource = new HashMap<>();
+ resource.put("path", "/test/path");
+
+ when(serviceRest.isServiceAdmin(serviceName)).thenReturn(true);
+ when(serviceRest.getPolicyAdminForDelegatedAdmin(serviceName)).thenReturn(policyAdmin);
+ when(searchUtil.getSearchFilter(request, Collections.emptyList())).thenReturn(filter);
+ when(filter.getParamsWithPrefix(SearchFilter.RESOURCE_PREFIX, true)).thenReturn(resource);
+ when(policyAdmin.getZoneNamesForResource(resource)).thenReturn(expectedZoneNames);
+
+ Collection<String> result = securityZoneREST.getZoneNamesForResource(serviceName, request);
+
+ assertNotNull(result);
+ assertEquals(2, result.size());
+ Assertions.assertEquals(expectedZoneNames, result);
+ verify(serviceRest, times(1)).isServiceAdmin(serviceName);
+ verify(serviceRest, times(1)).getPolicyAdminForDelegatedAdmin(serviceName);
+ verify(policyAdmin, times(1)).getZoneNamesForResource(anyMap());
+ }
+
+ @Test
+ public void testGetZoneNamesForResourceUnauthorized() throws Exception {
+ String serviceName = "test_service";
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicyAdmin policyAdmin = Mockito.mock(RangerPolicyAdmin.class);
+
+ when(serviceRest.isServiceAdmin(serviceName)).thenReturn(false);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("testuser");
+ when(restErrorUtil.createRESTException(HttpServletResponse.SC_FORBIDDEN, "User 'testuser' does not have privilege", true)).thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getZoneNamesForResource(serviceName, request);
+ });
+ verify(serviceRest, times(1)).isServiceAdmin(serviceName);
+ verify(serviceRest, never()).getPolicyAdminForDelegatedAdmin(serviceName);
+ verify(policyAdmin, never()).getZoneNamesForResource(anyMap());
+ }
+
+ @Test
+ public void testGetZoneNamesForResourcePolicyAdminNull() throws Exception {
+ String serviceName = "test_service";
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ when(serviceRest.isServiceAdmin(serviceName)).thenReturn(true);
+ when(serviceRest.getPolicyAdminForDelegatedAdmin(serviceName)).thenReturn(null);
+
+ Collection<String> result = securityZoneREST.getZoneNamesForResource(serviceName, request);
+
+ Assertions.assertNull(result);
+ verify(serviceRest).isServiceAdmin(serviceName);
+ verify(serviceRest).getPolicyAdminForDelegatedAdmin(serviceName);
+ }
+
+ @Test
+ public void testGetSecurityZoneHeaderInfoListByServiceId() throws Exception {
+ Long serviceId = 1L;
+ Boolean isTagService = false;
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerSecurityZoneHeaderInfo> expectedList = new ArrayList<>();
+ RangerSecurityZoneHeaderInfo headerInfo = new RangerSecurityZoneHeaderInfo();
+ headerInfo.setId(1L);
+ headerInfo.setName("zone1");
+ expectedList.add(headerInfo);
+
+ when(securityZoneStore.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request)).thenReturn(expectedList);
+
+ List<RangerSecurityZoneHeaderInfo> result = securityZoneREST.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request);
+
+ Assertions.assertEquals(expectedList, result);
+ verify(securityZoneStore).getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request);
+ }
+
+ @Test
+ public void testGetSecurityZoneHeaderInfoListByServiceIdWithException() throws Exception {
+ Long serviceId = 1L;
+ Boolean isTagService = false;
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ when(securityZoneStore.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request))
+ .thenThrow(new RuntimeException("General exception"));
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request);
+ });
+
+ verify(securityZoneStore).getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request);
+ verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void testGetSecurityZoneHeaderInfoListByServiceIdWithWebException() throws Exception {
+ Long serviceId = 1L;
+ Boolean isTagService = false;
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ when(securityZoneStore.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request))
+ .thenThrow(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request);
+ });
+
+ verify(securityZoneStore).getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService, request);
+ verify(restErrorUtil, never()).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void testGetZonesSummary() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+ PList<SecurityZoneSummary> expectedSummary = new PList<>();
+ SecurityZoneSummary summary = new SecurityZoneSummary();
+ summary.setName("zone1");
+ expectedSummary.setList(Arrays.asList(summary));
+
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(searchUtil.getSearchFilter(request, securityZoneService.sortFields)).thenReturn(filter);
+ when(securityZoneStore.getZonesSummary(filter)).thenReturn(expectedSummary);
+
+ PList<SecurityZoneSummary> result = securityZoneREST.getZonesSummary(request);
+
+ Assertions.assertEquals(expectedSummary, result);
+ verify(securityZoneStore).getZonesSummary(filter);
+ }
+
+ @Test
+ public void testGetZonesSummaryNoModuleAccess() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(false);
+ when(restErrorUtil.createRESTException(anyString(), any())).thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getZonesSummary(request);
+ });
+ }
+
+ @Test
+ public void testGetZonesSummaryWithException() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(searchUtil.getSearchFilter(request, securityZoneService.sortFields)).thenReturn(filter);
+ when(securityZoneStore.getZonesSummary(filter)).thenThrow(new RuntimeException("General exception"));
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getZonesSummary(request);
+ });
+
+ verify(securityZoneStore).getZonesSummary(filter);
+ verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void testGetZonesSummaryWithWebException() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(searchUtil.getSearchFilter(request, securityZoneService.sortFields)).thenReturn(filter);
+ when(securityZoneStore.getZonesSummary(filter)).thenThrow(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.getZonesSummary(request);
+ });
+
+ verify(securityZoneStore).getZonesSummary(filter);
+ }
+
+ @Test
+ public void testCreateSecurityZoneV2() throws Exception {
+ RangerSecurityZoneV2 zoneV2 = new RangerSecurityZoneV2();
+ RangerSecurityZone zoneV1 = createRangerSecurityZone();
+ zoneV2.setName("testzone1");
+
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ doNothing().when(validator).validate(any(RangerSecurityZone.class), eq(RangerValidator.Action.CREATE));
+ when(securityZoneStore.createSecurityZone(any(RangerSecurityZone.class))).thenReturn(zoneV1);
+
+ RangerSecurityZoneV2 result = securityZoneREST.createSecurityZone(zoneV2);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(zoneV1.getName(), result.getName());
+ }
+
+ @Test
+ public void testCreateSecurityZoneV2AdminAccessDenied() throws Exception {
+ RangerSecurityZoneV2 zoneV2 = new RangerSecurityZoneV2();
+ zoneV2.setName("testzone1");
+
+ when(rangerBizUtil.isAdmin()).thenReturn(false);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("nonAdminUser");
+ when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.createSecurityZone(zoneV2);
+ });
+
+ verify(rangerBizUtil).isAdmin();
+ verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any());
+ }
+
+ @Test
+ public void testCreateSecurityZoneV2OptimisticLockException() throws Exception {
+ RangerSecurityZoneV2 zoneV2 = new RangerSecurityZoneV2();
+ zoneV2.setName("testzone1");
+
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ doNothing().when(validator).validate(any(RangerSecurityZone.class), eq(RangerValidator.Action.CREATE));
+ when(securityZoneStore.createSecurityZone(any(RangerSecurityZone.class))).thenThrow(new OptimisticLockException());
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.createSecurityZone(zoneV2);
+ });
+
+ verify(securityZoneStore).createSecurityZone(any(RangerSecurityZone.class));
+ verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void testUpdateSecurityZoneV2() throws Exception {
+ Long zoneId = 2L;
+ RangerSecurityZoneV2 securityZoneV2 = new RangerSecurityZoneV2();
+ securityZoneV2.setId(zoneId);
+ securityZoneV2.setName("updatedTestZoneV2");
+ securityZoneV2.setServices(new HashMap<>());
+
+ RangerSecurityZone securityZoneV1 = securityZoneV2.toV1();
+
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ doNothing().when(validator).validate(any(RangerSecurityZone.class), eq(RangerValidator.Action.UPDATE));
+ when(securityZoneStore.updateSecurityZoneById(any(RangerSecurityZone.class))).thenReturn(securityZoneV1);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("rangerAdmin");
+
+ RangerSecurityZoneV2 result = securityZoneREST.updateSecurityZone(zoneId, securityZoneV2);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(securityZoneV1.getName(), result.getName());
+ }
+
+ @Test
+ public void testUpdateSecurityZoneV2WithUnzonedId() throws Exception {
+ Long zoneId = RangerSecurityZone.RANGER_UNZONED_SECURITY_ZONE_ID;
+ RangerSecurityZoneV2 securityZoneV2 = new RangerSecurityZoneV2();
+ securityZoneV2.setId(zoneId);
+
+ when(restErrorUtil.createRESTException("Cannot update unzoned zone")).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.updateSecurityZone(zoneId, securityZoneV2);
+ });
+
+ verify(restErrorUtil).createRESTException("Cannot update unzoned zone");
+ }
+
+ @Test
+ public void testUpdateSecurityZoneV2OptimisticLockException() throws Exception {
+ Long zoneId = 2L;
+ RangerSecurityZoneV2 securityZoneV2 = new RangerSecurityZoneV2();
+ securityZoneV2.setId(zoneId);
+ securityZoneV2.setName("testZoneV2");
+
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ doNothing().when(validator).validate(any(RangerSecurityZone.class), eq(RangerValidator.Action.UPDATE));
+ when(securityZoneStore.updateSecurityZoneById(any(RangerSecurityZone.class))).thenThrow(new OptimisticLockException());
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ securityZoneREST.updateSecurityZone(zoneId, securityZoneV2);
+ });
+
+ verify(securityZoneStore).updateSecurityZoneById(any(RangerSecurityZone.class));
+ verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void testUpdateSecurityZoneWithChangeRequest() throws Exception {
+ Long zoneId = 2L;
+ RangerSecurityZoneChangeRequest changeRequest = new RangerSecurityZoneChangeRequest();
+ RangerSecurityZone existingZone = createRangerSecurityZone();
+ existingZone.setId(zoneId);
+ existingZone.setName("existingZone");
+ existingZone.setServices(new HashMap<>());
+
+ RangerSecurityZone updatedZone = createRangerSecurityZone();
+ updatedZone.setId(zoneId);
+ updatedZone.setName("updatedZoneFromChange");
+ updatedZone.setServices(new HashMap<>());
+
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(securityZoneStore.getSecurityZone(zoneId)).thenReturn(existingZone);
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ doNothing().when(validator).validate(any(RangerSecurityZone.class), any());
+ when(securityZoneStore.updateSecurityZoneById(any(RangerSecurityZone.class))).thenReturn(updatedZone);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("admin");
+
+ SecurityZoneREST spySecurityZoneREST = Mockito.spy(securityZoneREST);
+ when(spySecurityZoneREST.getSecurityZone(zoneId)).thenReturn(existingZone);
+
+ Boolean result = spySecurityZoneREST.updateSecurityZone(zoneId, changeRequest);
+
+ Assertions.assertTrue(result);
+ verify(spySecurityZoneREST, times(2)).getSecurityZone(anyLong());
+ verify(securityZoneStore, times(1)).updateSecurityZoneById(any(RangerSecurityZone.class));
+ }
+
+ @Test
+ public void testUpdateSecurityZoneWithChangeRequestException() throws Exception {
+ Long zoneId = 2L;
+ RangerSecurityZoneChangeRequest changeRequest = new RangerSecurityZoneChangeRequest();
+ RangerSecurityZone existingZone = createRangerSecurityZone();
+ existingZone.setId(zoneId);
+
+ SecurityZoneREST spySecurityZoneREST = Mockito.spy(securityZoneREST);
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(spySecurityZoneREST.getSecurityZone(zoneId)).thenReturn(existingZone);
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ doNothing().when(validator).validate(any(RangerSecurityZone.class), any());
+ when(securityZoneStore.updateSecurityZoneById(any(RangerSecurityZone.class))).thenThrow(new RuntimeException("General exception"));
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ spySecurityZoneREST.updateSecurityZone(zoneId, changeRequest);
+ });
+
+ verify(securityZoneStore).updateSecurityZoneById(any(RangerSecurityZone.class));
+ verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void testUpdateSecurityZoneWithChangeRequestWebException() throws Exception {
+ Long zoneId = 2L;
+ RangerSecurityZoneChangeRequest changeRequest = new RangerSecurityZoneChangeRequest();
+ RangerSecurityZone existingZone = createRangerSecurityZone();
+ existingZone.setId(zoneId);
+
+ SecurityZoneREST spySecurityZoneREST = Mockito.spy(securityZoneREST);
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(spySecurityZoneREST.getSecurityZone(zoneId)).thenReturn(existingZone);
+ when(rangerBizUtil.isAdmin()).thenReturn(true);
+ when(validatorFactory.getSecurityZoneValidator(svcStore, securityZoneStore)).thenReturn(validator);
+ doNothing().when(validator).validate(any(RangerSecurityZone.class), any());
+ when(securityZoneStore.updateSecurityZoneById(any(RangerSecurityZone.class))).thenThrow(new WebApplicationException());
+
+ WebApplicationException thrown = assertThrows(WebApplicationException.class, () -> {
+ spySecurityZoneREST.updateSecurityZone(zoneId, changeRequest);
+ });
+
+ verify(securityZoneStore).updateSecurityZoneById(any(RangerSecurityZone.class));
+ verify(restErrorUtil, never()).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void testGetSecurityZoneV2ByName() throws Exception {
+ String zoneName = "testzone1";
+ RangerSecurityZone zoneV1 = createRangerSecurityZone();
+ zoneV1.setName(zoneName);
+
+ SecurityZoneREST spySecurityZoneREST = spy(securityZoneREST);
+ doReturn(zoneV1).when(spySecurityZoneREST).getSecurityZone(zoneName);
+
+ RangerSecurityZoneV2 result = spySecurityZoneREST.getSecurityZoneV2(zoneName);
+
+ Assertions.assertNotNull(result);
+ assertEquals(zoneName, result.getName());
+ verify(spySecurityZoneREST, times(1)).getSecurityZone(zoneName);
+ }
+
+ @Test
+ public void testGetSecurityZoneV2ById() throws Exception {
+ Long zoneId = 1L;
+ RangerSecurityZone zoneV1 = createRangerSecurityZone();
+ zoneV1.setId(zoneId);
+
+ SecurityZoneREST spySecurityZoneREST = spy(securityZoneREST);
+ doReturn(zoneV1).when(spySecurityZoneREST).getSecurityZone(zoneId);
+
+ RangerSecurityZoneV2 result = spySecurityZoneREST.getSecurityZoneV2(zoneId);
+
+ assertNotNull(result);
+ assertEquals(zoneId, result.getId());
+ verify(spySecurityZoneREST, times(1)).getSecurityZone(zoneId);
+ }
+
+ @Test
+ public void testGetAllZonesV2() throws Exception {
+ RangerSecurityZoneList zoneList = new RangerSecurityZoneList();
+ List<RangerSecurityZone> zones = Arrays.asList(createRangerSecurityZone());
+ zoneList.setSecurityZoneList(zones);
+ zoneList.setTotalCount(1);
+ zoneList.setResultSize(1);
+
+ SearchFilter filter = new SearchFilter();
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(searchUtil.getSearchFilter(request, securityZoneService.sortFields)).thenReturn(filter);
+ when(securityZoneStore.getSecurityZones(filter)).thenReturn(zones);
+
+ PList<RangerSecurityZoneV2> result = securityZoneREST.getAllZonesV2(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(1, result.getList().size());
+ Assertions.assertEquals("testzone1", result.getList().get(0).getName());
+ }
+
+ @Test
+ public void testGetResourcesByZoneId() throws Exception {
+ Long zoneId = 2L;
+ String serviceName = "test_service";
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerSecurityZone zone = createRangerSecurityZone();
+ zone.setId(zoneId);
+
+ SearchFilter filter = Mockito.mock(SearchFilter.class);
+
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(securityZoneStore.getSecurityZone(zoneId)).thenReturn(zone);
+
+ securityZoneREST.getResources(zoneId, serviceName, request);
+
+ verify(securityZoneStore).getSecurityZone(zoneId);
+ }
+
+ @Test
+ public void testGetResourcesByZoneName() throws Exception {
+ String zoneName = "testzone1";
+ String serviceName = "test_service";
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerSecurityZone zone = createRangerSecurityZone();
+ zone.setName(zoneName);
+
+ SearchFilter filter = new SearchFilter();
+ when(rangerBizUtil.hasModuleAccess(Mockito.anyString())).thenReturn(true);
+ when(securityZoneStore.getSecurityZoneByName(zoneName)).thenReturn(zone);
+
+ securityZoneREST.getResources(zoneName, serviceName, request);
+
+ verify(securityZoneStore).getSecurityZoneByName(zoneName);
+ }
+
+ @Test
+ public void testEnsureUserAllowOperationOnServiceForZone_NameChangeThrows() throws Exception {
+ RangerSecurityZone uiZone = createRangerSecurityZone();
+ uiZone.setId(5L);
+ uiZone.setName("changedZone");
+ RangerSecurityZone dbZone = createRangerSecurityZone();
+ dbZone.setId(5L);
+ dbZone.setName("originalZone");
+
+ when(rangerBizUtil.isAdmin()).thenReturn(false);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("user1");
+ when(svcStore.getSecurityZone(5L)).thenReturn(dbZone);
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.eq(true))).thenReturn(new WebApplicationException());
+
+ Method m = SecurityZoneREST.class.getDeclaredMethod("ensureUserAllowOperationOnServiceForZone", RangerSecurityZone.class);
+ m.setAccessible(true);
+
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(securityZoneREST, uiZone);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testEnsureUserAllowOperationOnServiceForZone_ServiceAssociationThrows() throws Exception {
+ RangerSecurityZone dbZone = createRangerSecurityZone();
+ dbZone.setId(7L);
+ // existing services: {"test_service_1"}
+ RangerSecurityZone uiZone = createRangerSecurityZone();
+ uiZone.setId(7L);
+ // add a new service to trigger diff
+ RangerSecurityZone.RangerSecurityZoneService extraSvc = new RangerSecurityZone.RangerSecurityZoneService();
+ extraSvc.setResources(new ArrayList<>());
+ uiZone.getServices().put("svc-new", extraSvc);
+
+ when(rangerBizUtil.isAdmin()).thenReturn(false);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("user2");
+ when(svcStore.getSecurityZone(7L)).thenReturn(dbZone);
+ when(serviceMgr.isZoneAdmin(dbZone.getName())).thenReturn(false);
+ when(svcStore.isServiceAdminUser(Mockito.eq("svc-new"), Mockito.eq("user2"))).thenReturn(false);
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.eq(true))).thenReturn(new WebApplicationException());
+
+ Method m = SecurityZoneREST.class.getDeclaredMethod("ensureUserAllowOperationOnServiceForZone", RangerSecurityZone.class);
+ m.setAccessible(true);
+
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(securityZoneREST, uiZone);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testThrowRestError_Direct() throws Exception {
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.eq(true))).thenReturn(new WebApplicationException());
+ Method m = SecurityZoneREST.class.getDeclaredMethod("throwRestError", String.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(securityZoneREST, "forbidden change");
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testGetResourcesPrivate_NoMatchingServiceReturnsNull() throws Exception {
+ RangerSecurityZone zone = createRangerSecurityZone();
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = Mockito.mock(SearchFilter.class);
+
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("user3");
+
+ Method m = SecurityZoneREST.class.getDeclaredMethod("getResources", RangerSecurityZone.class, String.class, HttpServletRequest.class);
+ m.setAccessible(true);
+ Object ret = m.invoke(securityZoneREST, zone, "unknown_service", request);
+ Assertions.assertNull(ret);
+ }
+
+ @Test
+ public void testGetResourcesPrivate_WithMatchingServiceReturnsPList() throws Exception {
+ RangerSecurityZone zone = createRangerSecurityZone();
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = Mockito.mock(SearchFilter.class);
+ when(filter.getStartIndex()).thenReturn(0);
+ when(filter.getMaxRows()).thenReturn(100);
+ when(searchUtil.getSearchFilter(request, Collections.emptyList())).thenReturn(filter);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("user4");
+
+ Method m = SecurityZoneREST.class.getDeclaredMethod("getResources", RangerSecurityZone.class, String.class, HttpServletRequest.class);
+ m.setAccessible(true);
+ @SuppressWarnings("unchecked")
+ PList<RangerSecurityZoneV2.RangerSecurityZoneResource> ret = (PList<RangerSecurityZoneV2.RangerSecurityZoneResource>) m.invoke(securityZoneREST, zone, "test_service_1", request);
+ assertNotNull(ret);
+ }
+
+ @Test
+ public void testEnsureUserAllowOperationOnServiceForZone_TagServiceChangeThrows() throws Exception {
+ RangerSecurityZone dbZone = createRangerSecurityZone();
+ dbZone.setId(11L);
+ dbZone.setTagServices(new ArrayList<>(Arrays.asList("tagA")));
+ RangerSecurityZone uiZone = createRangerSecurityZone();
+ uiZone.setId(11L);
+ uiZone.setTagServices(new ArrayList<>(Arrays.asList("tagA", "tagB")));
+
+ when(rangerBizUtil.isAdmin()).thenReturn(false);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("userTag");
+ when(svcStore.getSecurityZone(11L)).thenReturn(dbZone);
+ when(serviceMgr.isZoneAdmin(dbZone.getName())).thenReturn(false);
+ when(svcStore.isServiceAdminUser(Mockito.eq("tagB"), Mockito.eq("userTag"))).thenReturn(false);
+ when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.eq(true))).thenReturn(new WebApplicationException());
+
+ Method m = SecurityZoneREST.class.getDeclaredMethod("ensureUserAllowOperationOnServiceForZone", RangerSecurityZone.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(securityZoneREST, uiZone);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testEnsureUserAllowOperationOnServiceForZone_SvcStoreThrowsPropagatesAsRestError() throws Exception {
+ RangerSecurityZone uiZone = createRangerSecurityZone();
+ uiZone.setId(13L);
+
+ when(rangerBizUtil.isAdmin()).thenReturn(false);
+ when(rangerBizUtil.getCurrentUserLoginId()).thenReturn("userX");
+ when(svcStore.getSecurityZone(13L)).thenThrow(new RuntimeException("db error"));
+ when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ Method m = SecurityZoneREST.class.getDeclaredMethod("ensureUserAllowOperationOnServiceForZone", RangerSecurityZone.class);
+ m.setAccessible(true);
+ assertThrows(WebApplicationException.class, () -> {
+ try {
+ m.invoke(securityZoneREST, uiZone);
+ } catch (InvocationTargetException ite) {
+ throw (RuntimeException) ite.getCause();
+ }
+ });
+ }
+
+ @Test
+ public void testUpdateSecurityZoneWithChangeRequest_GetSecurityZoneWebException() throws Exception {
+ Long zoneId = 21L;
+ RangerSecurityZoneV2.RangerSecurityZoneChangeRequest changeRequest = new RangerSecurityZoneV2.RangerSecurityZoneChangeRequest();
+
+ SecurityZoneREST spySecurityZoneREST = Mockito.spy(securityZoneREST);
+ Mockito.doThrow(new WebApplicationException()).when(spySecurityZoneREST).getSecurityZone(zoneId);
+
+ assertThrows(WebApplicationException.class, () -> {
+ spySecurityZoneREST.updateSecurityZone(zoneId, changeRequest);
+ });
+ }
+
private RangerSecurityZone createRangerSecurityZone() {
String testZone1 = "testzone1";
List<String> testZone1ResoursesList = new ArrayList(Arrays.asList("/path/to/resource1", "/path/to/resource2"));
@@ -263,7 +1304,7 @@ private RangerSecurityZone createRangerSecurityZone() {
Map<String, RangerSecurityZoneService> services = new HashMap<>();
List<HashMap<String, List<String>>> resources = new ArrayList<>();
- HashMap<String, List<String>> resource = new HashMap<>();
+ HashMap<String, List<String>> resource = new HashMap<String, List<String>>();
resource.put("resource_path", testZone1ResoursesList);
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java
index 3a23d96ce..c3e3d6c33 100644
--- a/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java
@@ -20,7 +20,7 @@
import com.sun.jersey.core.header.FormDataContentDisposition;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.io.IOUtils;
-import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang3.StringUtils;
import org.apache.ranger.admin.client.datatype.RESTResponse;
import org.apache.ranger.biz.AssetMgr;
import org.apache.ranger.biz.RangerBizUtil;
@@ -32,6 +32,7 @@
import org.apache.ranger.biz.TagDBStore;
import org.apache.ranger.biz.XUserMgr;
import org.apache.ranger.common.ContextUtil;
+import org.apache.ranger.common.MessageEnums;
import org.apache.ranger.common.RESTErrorUtil;
import org.apache.ranger.common.RangerConstants;
import org.apache.ranger.common.RangerSearchUtil;
@@ -42,6 +43,7 @@
import org.apache.ranger.common.db.RangerTransactionSynchronizationAdapter;
import org.apache.ranger.db.RangerDaoManager;
import org.apache.ranger.db.XXPolicyDao;
+import org.apache.ranger.db.XXRoleDao;
import org.apache.ranger.db.XXSecurityZoneDao;
import org.apache.ranger.db.XXSecurityZoneRefServiceDao;
import org.apache.ranger.db.XXSecurityZoneRefTagServiceDao;
@@ -69,18 +71,22 @@
import org.apache.ranger.plugin.model.RangerServiceDef.RangerPolicyConditionDef;
import org.apache.ranger.plugin.model.RangerServiceDef.RangerResourceDef;
import org.apache.ranger.plugin.model.RangerServiceDef.RangerServiceConfigDef;
+import org.apache.ranger.plugin.model.RangerServiceHeaderInfo;
import org.apache.ranger.plugin.model.ServiceDeleteResponse;
import org.apache.ranger.plugin.model.validation.RangerPolicyValidator;
import org.apache.ranger.plugin.model.validation.RangerServiceDefValidator;
import org.apache.ranger.plugin.model.validation.RangerServiceValidator;
+import org.apache.ranger.plugin.model.validation.RangerValidator.Action;
import org.apache.ranger.plugin.policyengine.RangerAccessResource;
import org.apache.ranger.plugin.policyengine.RangerAccessResourceImpl;
import org.apache.ranger.plugin.policyengine.RangerPolicyEngineImpl;
import org.apache.ranger.plugin.service.ResourceLookupContext;
import org.apache.ranger.plugin.store.EmbeddedServiceDefsUtil;
import org.apache.ranger.plugin.store.PList;
+import org.apache.ranger.plugin.store.ServiceStore;
import org.apache.ranger.plugin.util.GrantRevokeRequest;
import org.apache.ranger.plugin.util.RangerPluginCapability;
+import org.apache.ranger.plugin.util.RangerPurgeResult;
import org.apache.ranger.plugin.util.SearchFilter;
import org.apache.ranger.plugin.util.ServicePolicies;
import org.apache.ranger.security.context.RangerContextHolder;
@@ -102,32 +108,36 @@
import org.apache.ranger.view.VXResponse;
import org.apache.ranger.view.VXString;
import org.apache.ranger.view.VXUser;
-import org.junit.Assert;
-import org.junit.FixMethodOrder;
-import org.junit.Ignore;
-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.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
import javax.ws.rs.WebApplicationException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
+import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
@@ -138,16 +148,18 @@
import static org.mockito.ArgumentMatchers.eq;
-@RunWith(MockitoJUnitRunner.class)
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+/**
+* @generated by Cursor
+* @description <Unit Test for TestServiceREST class>
+*/
+@ExtendWith(MockitoExtension.class)
+@TestMethodOrder(MethodOrderer.MethodName.class)
public class TestServiceREST {
private static final Long Id = 8L;
private final String grantor = "test-grantor-1";
private final String ownerUser = "test-owner-user-1";
private final String zoneName = "test-zone-1";
- @Rule
- public ExpectedException thrown = ExpectedException.none();
String importPoliceTestFilePath = "./src/test/java/org/apache/ranger/rest/importPolicy/import_policy_test_file.json";
@InjectMocks
ServiceREST serviceREST = new ServiceREST();
@@ -176,8 +188,6 @@ public class TestServiceREST {
@Mock
XUserService xUserService;
@Mock
- XUserMgr xUserMgr;
- @Mock
XUserMgr userMgr;
@Mock
RangerAuditFields rangerAuditFields;
@@ -343,18 +353,18 @@ public void test1createServiceDef() throws Exception {
Mockito.when(svcStore.createServiceDef(Mockito.any())).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = serviceREST.createServiceDef(rangerServiceDef);
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
- Assert.assertEquals(dbRangerServiceDef.getImplClass(), rangerServiceDef.getImplClass());
- Assert.assertEquals(dbRangerServiceDef.getLabel(), rangerServiceDef.getLabel());
- Assert.assertEquals(dbRangerServiceDef.getDescription(), rangerServiceDef.getDescription());
- Assert.assertEquals(dbRangerServiceDef.getRbKeyDescription(), rangerServiceDef.getRbKeyDescription());
- Assert.assertEquals(dbRangerServiceDef.getUpdatedBy(), rangerServiceDef.getUpdatedBy());
- Assert.assertEquals(dbRangerServiceDef.getUpdateTime(), rangerServiceDef.getUpdateTime());
- Assert.assertEquals(dbRangerServiceDef.getVersion(), rangerServiceDef.getVersion());
- Assert.assertEquals(dbRangerServiceDef.getConfigs(), rangerServiceDef.getConfigs());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertEquals(dbRangerServiceDef.getImplClass(), rangerServiceDef.getImplClass());
+ Assertions.assertEquals(dbRangerServiceDef.getLabel(), rangerServiceDef.getLabel());
+ Assertions.assertEquals(dbRangerServiceDef.getDescription(), rangerServiceDef.getDescription());
+ Assertions.assertEquals(dbRangerServiceDef.getRbKeyDescription(), rangerServiceDef.getRbKeyDescription());
+ Assertions.assertEquals(dbRangerServiceDef.getUpdatedBy(), rangerServiceDef.getUpdatedBy());
+ Assertions.assertEquals(dbRangerServiceDef.getUpdateTime(), rangerServiceDef.getUpdateTime());
+ Assertions.assertEquals(dbRangerServiceDef.getVersion(), rangerServiceDef.getVersion());
+ Assertions.assertEquals(dbRangerServiceDef.getConfigs(), rangerServiceDef.getConfigs());
Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
Mockito.verify(svcStore).createServiceDef(rangerServiceDef);
@@ -368,31 +378,30 @@ public void test2updateServiceDef() throws Exception {
Mockito.when(svcStore.updateServiceDef(Mockito.any())).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = serviceREST.updateServiceDef(rangerServiceDef, rangerServiceDef.getId());
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
- Assert.assertEquals(dbRangerServiceDef.getImplClass(), rangerServiceDef.getImplClass());
- Assert.assertEquals(dbRangerServiceDef.getLabel(), rangerServiceDef.getLabel());
- Assert.assertEquals(dbRangerServiceDef.getDescription(), rangerServiceDef.getDescription());
- Assert.assertEquals(dbRangerServiceDef.getRbKeyDescription(), rangerServiceDef.getRbKeyDescription());
- Assert.assertEquals(dbRangerServiceDef.getUpdatedBy(), rangerServiceDef.getUpdatedBy());
- Assert.assertEquals(dbRangerServiceDef.getUpdateTime(), rangerServiceDef.getUpdateTime());
- Assert.assertEquals(dbRangerServiceDef.getVersion(), rangerServiceDef.getVersion());
- Assert.assertEquals(dbRangerServiceDef.getConfigs(), rangerServiceDef.getConfigs());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertEquals(dbRangerServiceDef.getImplClass(), rangerServiceDef.getImplClass());
+ Assertions.assertEquals(dbRangerServiceDef.getLabel(), rangerServiceDef.getLabel());
+ Assertions.assertEquals(dbRangerServiceDef.getDescription(), rangerServiceDef.getDescription());
+ Assertions.assertEquals(dbRangerServiceDef.getRbKeyDescription(), rangerServiceDef.getRbKeyDescription());
+ Assertions.assertEquals(dbRangerServiceDef.getUpdatedBy(), rangerServiceDef.getUpdatedBy());
+ Assertions.assertEquals(dbRangerServiceDef.getUpdateTime(), rangerServiceDef.getUpdateTime());
+ Assertions.assertEquals(dbRangerServiceDef.getVersion(), rangerServiceDef.getVersion());
+ Assertions.assertEquals(dbRangerServiceDef.getConfigs(), rangerServiceDef.getConfigs());
Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
Mockito.verify(svcStore).updateServiceDef(rangerServiceDef);
}
@Test
- public void test3deleteServiceDef() {
+ public void test3deleteServiceDef() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
RangerServiceDef rangerServiceDef = rangerServiceDef();
XXServiceDef xServiceDef = serviceDef();
XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
- Mockito.when(validatorFactory.getServiceDefValidator(svcStore))
- .thenReturn(serviceDefValidator);
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore)).thenReturn(serviceDefValidator);
Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
Mockito.when(xServiceDefDao.getById(Id)).thenReturn(xServiceDef);
@@ -412,8 +421,8 @@ public void test4getServiceDefById() throws Exception {
Mockito.when(!bizUtil.hasAccess(xServiceDef, null)).thenReturn(true);
Mockito.when(svcStore.getServiceDef(rangerServiceDef.getId())).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = serviceREST.getServiceDef(rangerServiceDef.getId());
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
Mockito.verify(svcStore).getServiceDef(rangerServiceDef.getId());
Mockito.verify(daoManager).getXXServiceDef();
Mockito.verify(bizUtil).hasAccess(xServiceDef, null);
@@ -430,8 +439,8 @@ public void test5getServiceDefByName() throws Exception {
Mockito.when(!bizUtil.hasAccess(xServiceDef, null)).thenReturn(true);
Mockito.when(svcStore.getServiceDefByName(rangerServiceDef.getName())).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = serviceREST.getServiceDefByName(rangerServiceDef.getName());
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
Mockito.verify(svcStore).getServiceDefByName(rangerServiceDef.getName());
Mockito.verify(daoManager).getXXServiceDef();
}
@@ -449,19 +458,19 @@ public void test6createService() throws Exception {
Mockito.when(svcStore.createService(Mockito.any())).thenReturn(rangerService);
RangerService dbRangerService = serviceREST.createService(rangerService);
- Assert.assertNotNull(dbRangerService);
- Assert.assertEquals(rangerService, dbRangerService);
- Assert.assertEquals(rangerService.getId(), dbRangerService.getId());
- Assert.assertEquals(rangerService.getConfigs(), dbRangerService.getConfigs());
- Assert.assertEquals(rangerService.getDescription(), dbRangerService.getDescription());
- Assert.assertEquals(rangerService.getGuid(), dbRangerService.getGuid());
- Assert.assertEquals(rangerService.getName(), dbRangerService.getName());
- Assert.assertEquals(rangerService.getPolicyVersion(), dbRangerService.getPolicyVersion());
- Assert.assertEquals(rangerService.getType(), dbRangerService.getType());
- Assert.assertEquals(rangerService.getVersion(), dbRangerService.getVersion());
- Assert.assertEquals(rangerService.getCreateTime(), dbRangerService.getCreateTime());
- Assert.assertEquals(rangerService.getUpdateTime(), dbRangerService.getUpdateTime());
- Assert.assertEquals(rangerService.getUpdatedBy(), dbRangerService.getUpdatedBy());
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertEquals(rangerService, dbRangerService);
+ Assertions.assertEquals(rangerService.getId(), dbRangerService.getId());
+ Assertions.assertEquals(rangerService.getConfigs(), dbRangerService.getConfigs());
+ Assertions.assertEquals(rangerService.getDescription(), dbRangerService.getDescription());
+ Assertions.assertEquals(rangerService.getGuid(), dbRangerService.getGuid());
+ Assertions.assertEquals(rangerService.getName(), dbRangerService.getName());
+ Assertions.assertEquals(rangerService.getPolicyVersion(), dbRangerService.getPolicyVersion());
+ Assertions.assertEquals(rangerService.getType(), dbRangerService.getType());
+ Assertions.assertEquals(rangerService.getVersion(), dbRangerService.getVersion());
+ Assertions.assertEquals(rangerService.getCreateTime(), dbRangerService.getCreateTime());
+ Assertions.assertEquals(rangerService.getUpdateTime(), dbRangerService.getUpdateTime());
+ Assertions.assertEquals(rangerService.getUpdatedBy(), dbRangerService.getUpdatedBy());
Mockito.verify(validatorFactory).getServiceValidator(svcStore);
Mockito.verify(svcStore).createService(rangerService);
@@ -489,7 +498,7 @@ public void test7getServiceDefs() throws Exception {
Mockito.when(bizUtil.hasModuleAccess(RangerConstants.MODULE_RESOURCE_BASED_POLICIES)).thenReturn(true);
Mockito.when(svcStore.getPaginatedServiceDefs(filter)).thenReturn(serviceDefList);
RangerServiceDefList dbRangerServiceDef = serviceREST.getServiceDefs(request);
- Assert.assertNotNull(dbRangerServiceDef);
+ Assertions.assertNotNull(dbRangerServiceDef);
Mockito.verify(searchUtil).getSearchFilter(request, serviceDefService.sortFields);
Mockito.verify(svcStore).getPaginatedServiceDefs(filter);
}
@@ -510,44 +519,42 @@ public void test8updateServiceDef() throws Exception {
Mockito.when(svcStore.updateService(Mockito.any(), Mockito.any())).thenReturn(rangerService);
RangerService dbRangerService = serviceREST.updateService(rangerService, request);
- Assert.assertNotNull(dbRangerService);
- Assert.assertNotNull(dbRangerService);
- Assert.assertEquals(rangerService, dbRangerService);
- Assert.assertEquals(rangerService.getId(), dbRangerService.getId());
- Assert.assertEquals(rangerService.getConfigs(), dbRangerService.getConfigs());
- Assert.assertEquals(rangerService.getDescription(), dbRangerService.getDescription());
- Assert.assertEquals(rangerService.getGuid(), dbRangerService.getGuid());
- Assert.assertEquals(rangerService.getName(), dbRangerService.getName());
- Assert.assertEquals(rangerService.getPolicyVersion(), dbRangerService.getPolicyVersion());
- Assert.assertEquals(rangerService.getType(), dbRangerService.getType());
- Assert.assertEquals(rangerService.getVersion(), dbRangerService.getVersion());
- Assert.assertEquals(rangerService.getCreateTime(), dbRangerService.getCreateTime());
- Assert.assertEquals(rangerService.getUpdateTime(), dbRangerService.getUpdateTime());
- Assert.assertEquals(rangerService.getUpdatedBy(), dbRangerService.getUpdatedBy());
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertEquals(rangerService, dbRangerService);
+ Assertions.assertEquals(rangerService.getId(), dbRangerService.getId());
+ Assertions.assertEquals(rangerService.getConfigs(), dbRangerService.getConfigs());
+ Assertions.assertEquals(rangerService.getDescription(), dbRangerService.getDescription());
+ Assertions.assertEquals(rangerService.getGuid(), dbRangerService.getGuid());
+ Assertions.assertEquals(rangerService.getName(), dbRangerService.getName());
+ Assertions.assertEquals(rangerService.getPolicyVersion(), dbRangerService.getPolicyVersion());
+ Assertions.assertEquals(rangerService.getType(), dbRangerService.getType());
+ Assertions.assertEquals(rangerService.getVersion(), dbRangerService.getVersion());
+ Assertions.assertEquals(rangerService.getCreateTime(), dbRangerService.getCreateTime());
+ Assertions.assertEquals(rangerService.getUpdateTime(), dbRangerService.getUpdateTime());
+ Assertions.assertEquals(rangerService.getUpdatedBy(), dbRangerService.getUpdatedBy());
Mockito.verify(validatorFactory).getServiceValidator(svcStore);
Mockito.verify(daoManager).getXXServiceDef();
Mockito.verify(svcStore).updateService(rangerService, options);
}
@Test
- public void test9deleteService() {
- RangerService rangerService = rangerService();
- XXServiceDef xServiceDef = serviceDef();
- XXService xService = xService();
- XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
- XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
- Mockito.when(validatorFactory.getServiceValidator(svcStore)).thenReturn(serviceValidator);
-
- Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
- Mockito.when(xServiceDao.getById(Id)).thenReturn(xService);
- Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
- Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
-
- serviceREST.deleteService(rangerService.getId());
-
- Mockito.verify(validatorFactory).getServiceValidator(svcStore);
- Mockito.verify(daoManager).getXXService();
- Mockito.verify(daoManager).getXXServiceDef();
+ public void test9deleteService() throws Exception {
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ RangerService rangerService = rangerService();
+ XXServiceDef xServiceDef = serviceDef();
+ XXService xService = xService();
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ Mockito.when(validatorFactory.getServiceValidator(svcStore)).thenReturn(serviceValidator);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ serviceREST.deleteService(rangerService.getId());
+ Mockito.verify(validatorFactory).getServiceValidator(svcStore);
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(daoManager).getXXServiceDef();
+ });
}
@Test
@@ -555,7 +562,8 @@ public void test10getServiceById() throws Exception {
RangerService rangerService = rangerService();
Mockito.when(svcStore.getService(rangerService.getId())).thenReturn(rangerService);
RangerService dbRangerService = serviceREST.getService(rangerService.getId());
- Assert.assertNotNull(dbRangerService);
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertEquals(dbRangerService.getId(), dbRangerService.getId());
Mockito.verify(svcStore).getService(dbRangerService.getId());
}
@@ -564,7 +572,8 @@ public void test11getServiceByName() throws Exception {
RangerService rangerService = rangerService();
Mockito.when(svcStore.getServiceByName(rangerService.getName())).thenReturn(rangerService);
RangerService dbRangerService = serviceREST.getServiceByName(rangerService.getName());
- Assert.assertNotNull(dbRangerService);
+ Assertions.assertNotNull(dbRangerService);
+ Assertions.assertEquals(dbRangerService.getName(), dbRangerService.getName());
Mockito.verify(svcStore).getServiceByName(dbRangerService.getName());
}
@@ -573,8 +582,7 @@ public void test12deleteServiceDef() {
RangerServiceDef rangerServiceDef = rangerServiceDef();
XXServiceDef xServiceDef = serviceDef();
XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
- Mockito.when(validatorFactory.getServiceDefValidator(svcStore))
- .thenReturn(serviceDefValidator);
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore)).thenReturn(serviceDefValidator);
Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
Mockito.when(xServiceDefDao.getById(Id)).thenReturn(xServiceDef);
@@ -585,13 +593,13 @@ public void test12deleteServiceDef() {
}
@Test
- public void test13lookupResource() {
+ public void test13lookupResource() throws Exception {
String serviceName = "HDFS_1";
ResourceLookupContext context = new ResourceLookupContext();
context.setResourceName(serviceName);
context.setUserInput("HDFS");
List<String> list = serviceREST.lookupResource(serviceName, context);
- Assert.assertNotNull(list);
+ Assertions.assertNotNull(list);
}
@Test
@@ -607,7 +615,7 @@ public void test14grantAccess() throws Exception {
Mockito.when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(false);
RESTResponse restResponse = serviceREST.grantAccess(serviceName, grantRequestObj, request);
- Assert.assertNotNull(restResponse);
+ Assertions.assertNotNull(restResponse);
Mockito.verify(serviceUtil).isValidateHttpsAuthentication(serviceName, request);
}
@@ -666,11 +674,11 @@ public void test14_1_grantAccessWithMultiColumns() throws Exception {
Map<String, RangerPolicyResource> policyResourceMap = createPolicy.getResources();
List<String> createdPolicyColumns = policyResourceMap.get("column").getValues();
- Assert.assertTrue(createdPolicyColumns.containsAll(grantColumns));
+ Assertions.assertTrue(createdPolicyColumns.containsAll(grantColumns));
Mockito.when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(false);
RESTResponse restResponse = serviceREST.grantAccess(serviceName, grantRequestObj, request);
- Assert.assertNotNull(restResponse);
+ Assertions.assertNotNull(restResponse);
Mockito.verify(serviceUtil).isValidateHttpsAuthentication(serviceName, request);
}
@@ -694,7 +702,7 @@ public void test15revokeAccess() throws Exception {
revokeRequest.setUsers(userList);
RESTResponse restResponse = serviceREST.revokeAccess(serviceName, revokeRequest, request);
- Assert.assertNotNull(restResponse);
+ Assertions.assertNotNull(restResponse);
}
@Test
@@ -740,7 +748,7 @@ public void test16createPolicyFalse() throws Exception {
Mockito.when(svcStore.createPolicy(Mockito.any())).thenReturn(rangPolicy);
RangerPolicy dbRangerPolicy = serviceREST.createPolicy(rangerPolicy, null);
- Assert.assertNotNull(dbRangerPolicy);
+ Assertions.assertNotNull(dbRangerPolicy);
Mockito.verify(bizUtil, Mockito.times(2)).isAdmin();
Mockito.verify(validatorFactory).getPolicyValidator(svcStore);
@@ -749,7 +757,7 @@ public void test16createPolicyFalse() throws Exception {
}
@Test
- public void test17updatePolicyFalse() {
+ public void test17updatePolicyFalse() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
String userName = "admin";
@@ -768,8 +776,7 @@ public void test17updatePolicyFalse() {
XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
- Mockito.when(validatorFactory.getPolicyValidator(svcStore)).thenReturn(
- policyValidator);
+ Mockito.when(validatorFactory.getPolicyValidator(svcStore)).thenReturn(policyValidator);
Mockito.when(bizUtil.isAdmin()).thenReturn(true);
Mockito.when(bizUtil.getCurrentUserLoginId()).thenReturn(userName);
Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
@@ -777,7 +784,7 @@ public void test17updatePolicyFalse() {
Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
RangerPolicy dbRangerPolicy = serviceREST.updatePolicy(rangerPolicy, Id);
- Assert.assertNull(dbRangerPolicy);
+ Assertions.assertNull(dbRangerPolicy);
Mockito.verify(validatorFactory).getPolicyValidator(svcStore);
}
@@ -841,26 +848,26 @@ public void test19getPolicyFalse() throws Exception {
Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
RangerPolicy dbRangerPolicy = serviceREST.getPolicy(rangerPolicy.getId());
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
Mockito.verify(svcStore).getPolicy(rangerPolicy.getId());
}
@Test
- public void test20getPolicies() {
+ public void test20getPolicies() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
SearchFilter filter = new SearchFilter();
filter.setParam(SearchFilter.POLICY_NAME, "policyName");
filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
Mockito.when(searchUtil.getSearchFilter(request, policyService.sortFields)).thenReturn(filter);
RangerPolicyList dbRangerPolicy = serviceREST.getPolicies(request);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(0, dbRangerPolicy.getListSize());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getListSize(), 0);
Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields);
}
@Test
- public void test21countPolicies() {
+ public void test21countPolicies() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
SearchFilter filter = new SearchFilter();
@@ -869,7 +876,7 @@ public void test21countPolicies() {
Mockito.when(searchUtil.getSearchFilter(request, policyService.sortFields)).thenReturn(filter);
Long data = serviceREST.countPolicies(request);
- Assert.assertNotNull(data);
+ Assertions.assertNotNull(data);
Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields);
}
@@ -884,7 +891,7 @@ public void test22getServicePoliciesById() throws Exception {
Mockito.when(searchUtil.getSearchFilter(request, policyService.sortFields)).thenReturn(filter);
RangerPolicyList dbRangerPolicy = serviceREST.getServicePolicies(rangerPolicy.getId(), request);
- Assert.assertNotNull(dbRangerPolicy);
+ Assertions.assertNotNull(dbRangerPolicy);
Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields);
Mockito.verify(svcStore).getServicePolicies(Id, filter);
}
@@ -894,17 +901,18 @@ public void test23getServicePoliciesByName() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
RangerPolicy rangerPolicy = rangerPolicy();
- List<RangerPolicy> ret = Collections.emptyList();
+ List<RangerPolicy> ret = new ArrayList<>();
SearchFilter filter = new SearchFilter();
filter.setParam(SearchFilter.POLICY_NAME, "policyName");
filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
Mockito.when(searchUtil.getSearchFilter(request, policyService.sortFields)).thenReturn(filter);
- Mockito.when(svcStore.getServicePolicies(rangerPolicy.getName(), filter)).thenReturn(ret);
+ Mockito.when(svcStore.getServicePolicies(Mockito.eq(rangerPolicy.getName()), Mockito.eq(filter))).thenReturn(ret);
RangerPolicyList dbRangerPolicy = serviceREST.getServicePoliciesByName(rangerPolicy.getName(), request);
- Assert.assertNotNull(dbRangerPolicy);
+ Assertions.assertNotNull(dbRangerPolicy);
+ Mockito.verify(svcStore).getServicePolicies(Mockito.eq(rangerPolicy.getName()), Mockito.eq(filter));
}
@Test
@@ -915,7 +923,7 @@ public void test24getServicePoliciesIfUpdated() throws Exception {
String pluginId = "1";
ServicePolicies dbServicePolicies = serviceREST.getServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", false, capabilityVector, request);
- Assert.assertNull(dbServicePolicies);
+ Assertions.assertNull(dbServicePolicies);
}
@Test
@@ -927,7 +935,7 @@ public void test25getPolicies() throws Exception {
Mockito.when(svcStore.getPolicies(filter)).thenReturn(ret);
List<RangerPolicy> dbRangerPolicyList = serviceREST.getPolicies(filter);
- Assert.assertNotNull(dbRangerPolicyList);
+ Assertions.assertNotNull(dbRangerPolicyList);
Mockito.verify(svcStore).getPolicies(filter);
}
@@ -940,7 +948,7 @@ public void test26getServices() throws Exception {
Mockito.when(svcStore.getServices(filter)).thenReturn(ret);
List<RangerService> dbRangerService = serviceREST.getServices(filter);
- Assert.assertNotNull(dbRangerService);
+ Assertions.assertNotNull(dbRangerService);
Mockito.verify(svcStore).getServices(filter);
}
@@ -955,9 +963,9 @@ public void test27getPoliciesWithoutServiceAdmin() throws Exception {
Mockito.when(searchUtil.getSearchFilter(request, policyService.sortFields)).thenReturn(filter);
Mockito.when(svcStore.getPolicies(filter)).thenReturn(policies);
RangerPolicyList dbRangerPolicy = serviceREST.getPolicies(request);
- Assert.assertNotNull(dbRangerPolicy);
- /* here we are not setting service admin role,hence we will not get any policy without the service admin roles */
- Assert.assertEquals(0, dbRangerPolicy.getListSize());
+ Assertions.assertNotNull(dbRangerPolicy);
+ /*here we are not setting service admin role,hence we will not get any policy without the service admin roles*/
+ Assertions.assertEquals(dbRangerPolicy.getListSize(), 0);
Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields);
}
@@ -982,21 +990,20 @@ public void test28getPoliciesWithServiceAdmin() throws Exception {
/*here we are setting serviceAdminRole, so we will get the required policy with serviceAdmi role*/
Mockito.when(svcStore.isServiceAdminUser(rPol.getService(), null)).thenReturn(true);
RangerPolicyList dbRangerPolicy = spySVCRest.getPolicies(request);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(1, dbRangerPolicy.getListSize());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getListSize(), 1);
Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields);
Mockito.verify(svcStore).getPolicies(filter);
Mockito.verify(svcStore).isServiceAdminUser(rPol.getService(), null);
}
@Test
- public void test30getPolicyFromEventTime() {
+ public void test30getPolicyFromEventTime() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
String strdt = new Date().toString();
String userName = "Admin";
Set<String> userGroupsList = new HashSet<>();
-
userGroupsList.add("group1");
userGroupsList.add("group2");
Mockito.when(request.getParameter("eventTime")).thenReturn(strdt);
@@ -1010,44 +1017,45 @@ public void test30getPolicyFromEventTime() {
Mockito.when(bizUtil.isAdmin()).thenReturn(false);
Mockito.when(bizUtil.getCurrentUserLoginId()).thenReturn(userName);
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
-
- RangerPolicy dbRangerPolicy = serviceREST.getPolicyFromEventTime(request);
- Assert.assertNull(dbRangerPolicy);
- Mockito.verify(request).getParameter("eventTime");
- Mockito.verify(request).getParameter("policyId");
- Mockito.verify(request).getParameter("versionNo");
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+ //thrown.expect(WebApplicationException.class);
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ RangerPolicy dbRangerPolicy = serviceREST.getPolicyFromEventTime(request);
+ Assertions.assertNull(dbRangerPolicy);
+ Mockito.verify(request).getParameter("eventTime");
+ Mockito.verify(request).getParameter("policyId");
+ Mockito.verify(request).getParameter("versionNo");
+ });
}
@Test
- public void test31getServices() {
+ public void test31getServices() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
SearchFilter filter = new SearchFilter();
filter.setParam(SearchFilter.POLICY_NAME, "policyName");
filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
RangerServiceList dbRangerService = serviceREST.getServices(request);
- Assert.assertNull(dbRangerService);
+ Assertions.assertNull(dbRangerService);
}
@Test
- public void test32getPolicyVersionList() {
+ public void test32getPolicyVersionList() throws Exception {
VXString vXString = new VXString();
vXString.setValue("1");
Mockito.when(svcStore.getPolicyVersionList(Id)).thenReturn(vXString);
VXString dbVXString = serviceREST.getPolicyVersionList(Id);
- Assert.assertNotNull(dbVXString);
+ Assertions.assertNotNull(dbVXString);
Mockito.verify(svcStore).getPolicyVersionList(Id);
}
@Test
- public void test33getPolicyForVersionNumber() {
+ public void test33getPolicyForVersionNumber() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
Mockito.when(svcStore.getPolicyForVersionNumber(Id, 1)).thenReturn(rangerPolicy);
Mockito.when(bizUtil.isAdmin()).thenReturn(true);
RangerPolicy dbRangerPolicy = serviceREST.getPolicyForVersionNumber(Id, 1);
- Assert.assertNotNull(dbRangerPolicy);
+ Assertions.assertNotNull(dbRangerPolicy);
Mockito.verify(svcStore).getPolicyForVersionNumber(Id, 1);
}
@@ -1062,7 +1070,7 @@ public void test34countServices() throws Exception {
Mockito.when(svcStore.getPaginatedServices(filter)).thenReturn(ret);
Long data = serviceREST.countServices(request);
- Assert.assertNotNull(data);
+ Assertions.assertNotNull(data);
Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields);
Mockito.verify(svcStore).getPaginatedServices(filter);
}
@@ -1072,7 +1080,7 @@ public void test35validateConfig() throws Exception {
RangerService rangerService = rangerService();
Mockito.when(serviceMgr.validateConfig(rangerService, svcStore)).thenReturn(vXResponse);
VXResponse dbVXResponse = serviceREST.validateConfig(rangerService);
- Assert.assertNotNull(dbVXResponse);
+ Assertions.assertNotNull(dbVXResponse);
Mockito.verify(serviceMgr).validateConfig(rangerService, svcStore);
}
@@ -1123,7 +1131,7 @@ public void test40applyPolicy() {
String resultPolicyStr = existingPolicy.toString();
System.out.println("resultPolicy = " + resultPolicyStr);
- Assert.assertTrue(true);
+ Assertions.assertTrue(true);
}
@Test
@@ -1220,7 +1228,7 @@ public void test41applyPolicy() {
String resultPolicyStr = existingPolicy.toString();
System.out.println("resultPolicy = " + resultPolicyStr);
- Assert.assertTrue(true);
+ Assertions.assertTrue(true);
}
@Test
@@ -1314,7 +1322,7 @@ public void test42grant() {
String resultPolicyStr = existingPolicy.toString();
System.out.println("resultPolicy = " + resultPolicyStr);
- Assert.assertTrue(true);
+ Assertions.assertTrue(true);
}
@Test
@@ -1409,18 +1417,18 @@ public void test43revoke() {
String resultPolicyStr = existingPolicy.toString();
System.out.println("resultPolicy=" + resultPolicyStr);
- Assert.assertTrue(true);
+ Assertions.assertTrue(true);
}
@Test
- public void test44getPolicyLabels() {
+ public void test44getPolicyLabels() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
SearchFilter filter = new SearchFilter();
Mockito.when(searchUtil.getSearchFilter(request, policyLabelsService.sortFields)).thenReturn(filter);
List<String> ret = new ArrayList<>();
Mockito.when(svcStore.getPolicyLabels(filter)).thenReturn(ret);
ret = serviceREST.getPolicyLabels(request);
- Assert.assertNotNull(ret);
+ Assertions.assertNotNull(ret);
Mockito.verify(searchUtil).getSearchFilter(request, policyLabelsService.sortFields);
}
@@ -1660,7 +1668,7 @@ public void test51getMetricByType() throws Exception {
}
@Test
- public void test52deleteService() {
+ public void test52deleteService() throws Exception {
RangerService rangerService = rangerService();
XXService xService = xService();
List<XXService> referringServices = new ArrayList<>();
@@ -1685,26 +1693,27 @@ public void test52deleteService() {
Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
Mockito.when(xServiceDao.findByTagServiceId(Mockito.anyLong())).thenReturn(referringServices);
Mockito.when(xServiceDao.getById(Id)).thenReturn(xService);
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
- serviceREST.deleteService(rangerService.getId());
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.deleteService(rangerService.getId());
+ });
}
@Test
- public void test53getPoliciesForResource() {
+ public void test53getPoliciesForResource() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
List<RangerService> rsList = new ArrayList<>();
RangerService rs = rangerService();
rsList.add(rs);
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
-
- serviceREST.getPoliciesForResource("servicedefname", "servicename", request);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getPoliciesForResource("servicedefname", "servicename", request);
+ });
}
@Test
- public void test54getPluginsInfo() {
+ public void test54getPluginsInfo() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
SearchFilter filter = new SearchFilter();
filter.setParam(SearchFilter.POLICY_NAME, "policyName");
@@ -1713,7 +1722,7 @@ public void test54getPluginsInfo() {
Mockito.when(searchUtil.getSearchFilter(request, pluginInfoService.getSortFields())).thenReturn(filter);
Mockito.when(pluginInfoService.searchRangerPluginInfo(filter)).thenReturn(paginatedPluginsInfo);
RangerPluginInfoList rPluginInfoList = serviceREST.getPluginsInfo(request);
- Assert.assertNotNull(rPluginInfoList);
+ Assertions.assertNotNull(rPluginInfoList);
Mockito.verify(searchUtil).getSearchFilter(request, pluginInfoService.getSortFields());
Mockito.verify(pluginInfoService).searchRangerPluginInfo(filter);
}
@@ -1725,9 +1734,10 @@ public void test55getServicePoliciesIfUpdatedCatch() throws Exception {
Long lastKnownVersion = 1L;
String pluginId = "1";
Mockito.when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
- serviceREST.getServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", false, capabilityVector, request);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", false, capabilityVector, request);
+ });
}
@Test
@@ -1740,7 +1750,7 @@ public void test56getServicePoliciesIfUpdated() throws Exception {
Mockito.when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
Mockito.when(svcStore.getServicePoliciesIfUpdated(Mockito.anyString(), Mockito.anyLong(), Mockito.anyBoolean())).thenReturn(servicePolicies);
ServicePolicies dbServicePolicies = serviceREST.getServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", true, capabilityVector, request);
- Assert.assertNotNull(dbServicePolicies);
+ Assertions.assertNotNull(dbServicePolicies);
}
@Test
@@ -1759,10 +1769,10 @@ public void test57getSecureServicePoliciesIfUpdatedFail() throws Exception {
Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
Mockito.when(svcStore.getServiceByName(serviceName)).thenReturn(rs);
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
-
- serviceREST.getSecureServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", false, capabilityVector, request);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getSecureServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", false, capabilityVector, request);
+ });
}
@Test
@@ -1784,10 +1794,10 @@ public void test58getSecureServicePoliciesIfUpdatedAllowedFail() throws Exceptio
Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
Mockito.when(svcStore.getServiceByNameForDP(serviceName)).thenReturn(rs);
Mockito.when(bizUtil.isUserAllowed(rs, ServiceREST.Allowed_User_List_For_Grant_Revoke)).thenReturn(true);
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
-
- serviceREST.getSecureServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", false, capabilityVector, request);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getSecureServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", false, capabilityVector, request);
+ });
}
@Test
@@ -1811,18 +1821,20 @@ public void test59getSecureServicePoliciesIfUpdatedSuccess() throws Exception {
Mockito.when(svcStore.getServiceByNameForDP(serviceName)).thenReturn(rs);
Mockito.when(bizUtil.isUserAllowed(rs, ServiceREST.Allowed_User_List_For_Grant_Revoke)).thenReturn(true);
Mockito.when(svcStore.getServicePoliciesIfUpdated(Mockito.anyString(), Mockito.anyLong(), Mockito.anyBoolean())).thenReturn(sp);
- ServicePolicies dbServiceSecurePolicies = serviceREST.getSecureServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", true, capabilityVector, request);
- Assert.assertNotNull(dbServiceSecurePolicies);
- Mockito.verify(serviceUtil).isValidService(serviceName, request);
- Mockito.verify(xServiceDao).findByName(serviceName);
- Mockito.verify(xServiceDefDao).getById(xService.getType());
- Mockito.verify(svcStore).getServiceByNameForDP(serviceName);
- Mockito.verify(bizUtil).isUserAllowed(rs, ServiceREST.Allowed_User_List_For_Grant_Revoke);
- Mockito.verify(svcStore).getServicePoliciesIfUpdated(serviceName, lastKnownVersion, false);
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ ServicePolicies dbServiceSecurePolicies = serviceREST.getSecureServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", true, capabilityVector, request);
+ Assertions.assertNotNull(dbServiceSecurePolicies);
+ Mockito.verify(serviceUtil).isValidService(serviceName, request);
+ Mockito.verify(xServiceDao).findByName(serviceName);
+ Mockito.verify(xServiceDefDao).getById(xService.getType());
+ Mockito.verify(svcStore).getServiceByNameForDP(serviceName);
+ Mockito.verify(bizUtil).isUserAllowed(rs, ServiceREST.Allowed_User_List_For_Grant_Revoke);
+ Mockito.verify(svcStore).getServicePoliciesIfUpdated(serviceName, lastKnownVersion, false);
+ });
}
@Test
- public void test60getPolicyFromEventTime() {
+ public void test60getPolicyFromEventTime() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
String strdt = new Date().toString();
@@ -1838,10 +1850,10 @@ public void test60getPolicyFromEventTime() {
policy.setResources(resources);
Mockito.when(svcStore.getPolicyFromEventTime(strdt, 1L)).thenReturn(null);
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
-
- serviceREST.getPolicyFromEventTime(request);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getPolicyFromEventTime(request);
+ });
}
@Test
@@ -1871,13 +1883,13 @@ public void test61getServiceWillOnlyReturnNameIdAndTypeForRoleUser() throws Exce
Mockito.when(svcStore.getService(Id)).thenReturn(actualService);
RangerService service = serviceREST.getService(Id);
- Assert.assertNotNull(service);
+ Assertions.assertNotNull(service);
Mockito.verify(svcStore).getService(Id);
- Assert.assertNull(service.getDescription());
- Assert.assertTrue(service.getConfigs().isEmpty());
- Assert.assertEquals(Id, service.getId());
- Assert.assertEquals("HDFS_1", service.getName());
- Assert.assertEquals("1", service.getType());
+ Assertions.assertNull(service.getDescription());
+ Assertions.assertTrue(service.getConfigs().isEmpty());
+ Assertions.assertEquals(service.getId(), Id);
+ Assertions.assertEquals(service.getName(), "HDFS_1");
+ Assertions.assertEquals(service.getType(), "1");
}
@Test
@@ -1907,13 +1919,13 @@ public void test62getServiceByNameWillOnlyReturnNameIdAndTypeForRoleUser() throw
Mockito.when(svcStore.getServiceByName(actualService.getName())).thenReturn(actualService);
RangerService service = serviceREST.getServiceByName(actualService.getName());
- Assert.assertNotNull(service);
+ Assertions.assertNotNull(service);
Mockito.verify(svcStore).getServiceByName(actualService.getName());
- Assert.assertNull(service.getDescription());
- Assert.assertTrue(service.getConfigs().isEmpty());
- Assert.assertEquals(Id, service.getId());
- Assert.assertEquals("HDFS_1", service.getName());
- Assert.assertEquals("1", service.getType());
+ Assertions.assertNull(service.getDescription());
+ Assertions.assertTrue(service.getConfigs().isEmpty());
+ Assertions.assertEquals(service.getId(), Id);
+ Assertions.assertEquals(service.getName(), "HDFS_1");
+ Assertions.assertEquals(service.getType(), "1");
}
@Test
@@ -1979,18 +1991,18 @@ public void test63getServices() throws Exception {
Mockito.when(svcStore.getPaginatedServices(filter)).thenReturn(paginatedSvcs);
Mockito.when(xUserService.getXUserByUserName("testuser")).thenReturn(loggedInUser);
RangerServiceList retServiceList = serviceREST.getServices(request);
- Assert.assertNotNull(retServiceList);
- Assert.assertNull(retServiceList.getServices().get(0).getDescription());
- Assert.assertTrue(retServiceList.getServices().get(0).getConfigs().isEmpty());
- Assert.assertNull(retServiceList.getServices().get(1).getDescription());
- Assert.assertTrue(retServiceList.getServices().get(1).getConfigs().isEmpty());
- Assert.assertEquals(Id, retServiceList.getServices().get(0).getId());
- Assert.assertEquals("HDFS_1", retServiceList.getServices().get(0).getName());
- Assert.assertEquals("1", retServiceList.getServices().get(0).getType());
-
- Assert.assertEquals(retServiceList.getServices().get(1).getId(), svc2.getId());
- Assert.assertEquals("YARN_1", retServiceList.getServices().get(1).getName());
- Assert.assertEquals("yarn", retServiceList.getServices().get(1).getType());
+ Assertions.assertNotNull(retServiceList);
+ Assertions.assertNull(retServiceList.getServices().get(0).getDescription());
+ Assertions.assertTrue(retServiceList.getServices().get(0).getConfigs().isEmpty());
+ Assertions.assertNull(retServiceList.getServices().get(1).getDescription());
+ Assertions.assertTrue(retServiceList.getServices().get(1).getConfigs().isEmpty());
+ Assertions.assertEquals(retServiceList.getServices().get(0).getId(), Id);
+ Assertions.assertEquals(retServiceList.getServices().get(0).getName(), "HDFS_1");
+ Assertions.assertEquals(retServiceList.getServices().get(0).getType(), "1");
+
+ Assertions.assertEquals(retServiceList.getServices().get(1).getId(), svc2.getId());
+ Assertions.assertEquals(retServiceList.getServices().get(1).getName(), "YARN_1");
+ Assertions.assertEquals(retServiceList.getServices().get(1).getType(), "yarn");
}
public void mockValidateGrantRevokeRequest() {
@@ -2000,7 +2012,6 @@ public void mockValidateGrantRevokeRequest() {
}
@Test
- @Ignore
public void test14bGrantAccess() throws Exception {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
String serviceName = "HDFS_1";
@@ -2010,16 +2021,16 @@ public void test14bGrantAccess() throws Exception {
mockValidateGrantRevokeRequest();
Mockito.when(xUserService.getXUserByUserName(Mockito.anyString())).thenReturn(Mockito.mock(VXUser.class));
Mockito.when(svcStore.getServiceByName(Mockito.anyString())).thenReturn(Mockito.mock(RangerService.class));
+ Mockito.when(daoManager.getXXServiceDef().findServiceDefTypeByServiceName(Mockito.anyString())).thenReturn("hdfs");
Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
RESTResponse restResponse = serviceREST.grantAccess(serviceName, grantRequestObj, request);
Mockito.verify(svcStore, Mockito.times(1)).createPolicy(Mockito.any(RangerPolicy.class));
-
- Assert.assertNotNull(restResponse);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, restResponse.getStatusCode());
+ Assertions.assertNotNull(restResponse);
+ Assertions.assertEquals(restResponse.getStatusCode(), RESTResponse.STATUS_SUCCESS);
}
@Test
- @Ignore
public void test64SecureGrantAccess() {
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
String serviceName = "HDFS_1";
@@ -2047,8 +2058,8 @@ public void test64SecureGrantAccess() {
throw new RuntimeException(e);
}
- Assert.assertNotNull(restResponse);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, restResponse.getStatusCode());
+ Assertions.assertNotNull(restResponse);
+ Assertions.assertEquals(RESTResponse.STATUS_SUCCESS, restResponse.getStatusCode());
}
@Test
@@ -2062,8 +2073,8 @@ public void test15bRevokeAccess() throws Exception {
Mockito.when(xUserService.getXUserByUserName(Mockito.anyString())).thenReturn(Mockito.mock(VXUser.class));
Mockito.when(bizUtil.isUserRangerAdmin(Mockito.anyString())).thenReturn(true);
RESTResponse restResponse = serviceREST.revokeAccess(serviceName, revokeRequest, request);
- Assert.assertNotNull(restResponse);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, restResponse.getStatusCode());
+ Assertions.assertNotNull(restResponse);
+ Assertions.assertEquals(RESTResponse.STATUS_SUCCESS, restResponse.getStatusCode());
}
@Test
@@ -2089,8 +2100,8 @@ public void test65SecureRevokeAccess() {
} catch (Exception e) {
throw new RuntimeException(e);
}
- Assert.assertNotNull(restResponse);
- Assert.assertEquals(RESTResponse.STATUS_SUCCESS, restResponse.getStatusCode());
+ Assertions.assertNotNull(restResponse);
+ Assertions.assertEquals(RESTResponse.STATUS_SUCCESS, restResponse.getStatusCode());
}
@Test
@@ -2100,9 +2111,9 @@ public void test66ApplyPolicy() {
RangerPolicy policy = rangerPolicy();
Mockito.doReturn(policy).when(serviceRESTSpy).createPolicy(Mockito.any(RangerPolicy.class), eq(null));
RangerPolicy returnedPolicy = serviceRESTSpy.applyPolicy(policy, request);
- Assert.assertNotNull(returnedPolicy);
- Assert.assertEquals(returnedPolicy.getId(), policy.getId());
- Assert.assertEquals(returnedPolicy.getName(), policy.getName());
+ Assertions.assertNotNull(returnedPolicy);
+ Assertions.assertEquals(returnedPolicy.getId(), policy.getId());
+ Assertions.assertEquals(returnedPolicy.getName(), policy.getName());
}
@Test
@@ -2117,7 +2128,7 @@ public void test67ResetPolicyCacheForAdmin() {
}
Mockito.when(svcStore.resetPolicyCache(serviceName)).thenReturn(res);
boolean isReset = serviceREST.resetPolicyCache(serviceName);
- Assert.assertEquals(res, isReset);
+ Assertions.assertEquals(res, isReset);
try {
Mockito.verify(svcStore).getServiceByName(serviceName);
} catch (Exception ignored) {
@@ -2130,7 +2141,7 @@ public void test68ResetPolicyCacheAll() {
Mockito.when(bizUtil.isAdmin()).thenReturn(true);
Mockito.when(svcStore.resetPolicyCache(null)).thenReturn(res);
boolean isReset = serviceREST.resetPolicyCacheAll();
- Assert.assertEquals(res, isReset);
+ Assertions.assertEquals(res, isReset);
}
@Test
@@ -2173,15 +2184,15 @@ public void test71DeleteClusterServices() {
Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
ResponseEntity<List<ServiceDeleteResponse>> deletedResponse = serviceREST.deleteClusterServices(clusterName);
- Assert.assertEquals(HttpStatus.OK, deletedResponse.getStatusCode());
- Assert.assertNotEquals(null, deletedResponse.getBody());
+ Assertions.assertEquals(HttpStatus.OK, deletedResponse.getStatusCode());
+ Assertions.assertNotEquals(null, deletedResponse.getBody());
for (ServiceDeleteResponse response : deletedResponse.getBody()) {
- Assert.assertTrue(response.getIsDeleted());
+ Assertions.assertTrue(response.getIsDeleted());
}
}
@Test
- public void test72updatePolicyWithPolicyIdIsNull() {
+ public void test72updatePolicyWithPolicyIdIsNull() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
Long policyId = rangerPolicy.getId();
rangerPolicy.setId(null);
@@ -2210,12 +2221,12 @@ public void test72updatePolicyWithPolicyIdIsNull() {
Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
RangerPolicy dbRangerPolicy = serviceREST.updatePolicy(rangerPolicy, policyId);
- Assert.assertNull(dbRangerPolicy);
+ Assertions.assertNull(dbRangerPolicy);
Mockito.verify(validatorFactory).getPolicyValidator(svcStore);
}
@Test
- public void test72updatePolicyWithInvalidPolicyId() {
+ public void test72updatePolicyWithInvalidPolicyId() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
Set<String> userGroupsList = new HashSet<>();
@@ -2233,11 +2244,12 @@ public void test72updatePolicyWithInvalidPolicyId() {
Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
- RangerPolicy dbRangerPolicy = serviceREST.updatePolicy(rangerPolicy, -11L);
- Assert.assertNull(dbRangerPolicy);
- Mockito.verify(validatorFactory).getPolicyValidator(svcStore);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ RangerPolicy dbRangerPolicy = serviceREST.updatePolicy(rangerPolicy, -11L);
+ Assertions.assertNull(dbRangerPolicy);
+ Mockito.verify(validatorFactory).getPolicyValidator(svcStore);
+ });
}
@Test
@@ -2249,18 +2261,18 @@ public void test73updateServiceDefWhenIdIsNull() throws Exception {
Mockito.when(svcStore.updateServiceDef(Mockito.any())).thenReturn(rangerServiceDef);
RangerServiceDef dbRangerServiceDef = serviceREST.updateServiceDef(rangerServiceDef, rangerServiceDef.getId());
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
- Assert.assertEquals(dbRangerServiceDef.getImplClass(), rangerServiceDef.getImplClass());
- Assert.assertEquals(dbRangerServiceDef.getLabel(), rangerServiceDef.getLabel());
- Assert.assertEquals(dbRangerServiceDef.getDescription(), rangerServiceDef.getDescription());
- Assert.assertEquals(dbRangerServiceDef.getRbKeyDescription(), rangerServiceDef.getRbKeyDescription());
- Assert.assertEquals(dbRangerServiceDef.getUpdatedBy(), rangerServiceDef.getUpdatedBy());
- Assert.assertEquals(dbRangerServiceDef.getUpdateTime(), rangerServiceDef.getUpdateTime());
- Assert.assertEquals(dbRangerServiceDef.getVersion(), rangerServiceDef.getVersion());
- Assert.assertEquals(dbRangerServiceDef.getConfigs(), rangerServiceDef.getConfigs());
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertEquals(dbRangerServiceDef.getImplClass(), rangerServiceDef.getImplClass());
+ Assertions.assertEquals(dbRangerServiceDef.getLabel(), rangerServiceDef.getLabel());
+ Assertions.assertEquals(dbRangerServiceDef.getDescription(), rangerServiceDef.getDescription());
+ Assertions.assertEquals(dbRangerServiceDef.getRbKeyDescription(), rangerServiceDef.getRbKeyDescription());
+ Assertions.assertEquals(dbRangerServiceDef.getUpdatedBy(), rangerServiceDef.getUpdatedBy());
+ Assertions.assertEquals(dbRangerServiceDef.getUpdateTime(), rangerServiceDef.getUpdateTime());
+ Assertions.assertEquals(dbRangerServiceDef.getVersion(), rangerServiceDef.getVersion());
+ Assertions.assertEquals(dbRangerServiceDef.getConfigs(), rangerServiceDef.getConfigs());
Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
Mockito.verify(svcStore).updateServiceDef(rangerServiceDef);
@@ -2270,25 +2282,26 @@ public void test73updateServiceDefWhenIdIsNull() throws Exception {
public void test74updateServiceDefWithInvalidDefId() throws Exception {
RangerServiceDef rangerServiceDef = rangerServiceDef();
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
-
- RangerServiceDef dbRangerServiceDef = serviceREST.updateServiceDef(rangerServiceDef, -1L);
- Assert.assertNotNull(dbRangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
- Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
- Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
- Assert.assertEquals(dbRangerServiceDef.getImplClass(), rangerServiceDef.getImplClass());
- Assert.assertEquals(dbRangerServiceDef.getLabel(), rangerServiceDef.getLabel());
- Assert.assertEquals(dbRangerServiceDef.getDescription(), rangerServiceDef.getDescription());
- Assert.assertEquals(dbRangerServiceDef.getRbKeyDescription(), rangerServiceDef.getRbKeyDescription());
- Assert.assertEquals(dbRangerServiceDef.getUpdatedBy(), rangerServiceDef.getUpdatedBy());
- Assert.assertEquals(dbRangerServiceDef.getUpdateTime(), rangerServiceDef.getUpdateTime());
- Assert.assertEquals(dbRangerServiceDef.getVersion(), rangerServiceDef.getVersion());
- Assert.assertEquals(dbRangerServiceDef.getConfigs(), rangerServiceDef.getConfigs());
-
- Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
- Mockito.verify(svcStore).updateServiceDef(rangerServiceDef);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+ //thrown.expect(WebApplicationException.class);
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ RangerServiceDef dbRangerServiceDef = serviceREST.updateServiceDef(rangerServiceDef, -1L);
+ Assertions.assertNotNull(dbRangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assertions.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assertions.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assertions.assertEquals(dbRangerServiceDef.getImplClass(), rangerServiceDef.getImplClass());
+ Assertions.assertEquals(dbRangerServiceDef.getLabel(), rangerServiceDef.getLabel());
+ Assertions.assertEquals(dbRangerServiceDef.getDescription(), rangerServiceDef.getDescription());
+ Assertions.assertEquals(dbRangerServiceDef.getRbKeyDescription(), rangerServiceDef.getRbKeyDescription());
+ Assertions.assertEquals(dbRangerServiceDef.getUpdatedBy(), rangerServiceDef.getUpdatedBy());
+ Assertions.assertEquals(dbRangerServiceDef.getUpdateTime(), rangerServiceDef.getUpdateTime());
+ Assertions.assertEquals(dbRangerServiceDef.getVersion(), rangerServiceDef.getVersion());
+ Assertions.assertEquals(dbRangerServiceDef.getConfigs(), rangerServiceDef.getConfigs());
+
+ Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
+ Mockito.verify(svcStore).updateServiceDef(rangerServiceDef);
+ });
}
@Test
@@ -2310,8 +2323,8 @@ public void test75GetPolicyByGUIDAndServiceNameAndZoneName() throws Exception {
Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
Mockito.when(svcStore.getPolicy(rangerPolicy.getGuid(), serviceName, zoneName)).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = serviceREST.getPolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), serviceName, zoneName);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
Mockito.verify(svcStore).getPolicy(rangerPolicy.getGuid(), serviceName, zoneName);
}
@@ -2342,8 +2355,8 @@ public void test76GetPolicyByGUID() throws Exception {
Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
Mockito.when(svcStore.getPolicy(rangerPolicy.getGuid(), null, null)).thenReturn(rangerPolicy);
RangerPolicy dbRangerPolicy = serviceREST.getPolicyByGUIDAndServiceNameAndZoneName(rangerPolicy.getGuid(), null, null);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
Mockito.verify(svcStore).getPolicy(rangerPolicy.getGuid(), null, null);
}
@@ -2413,7 +2426,7 @@ public void test78ResetPolicyCacheByServiceNameForServiceAdmin() {
} catch (Exception ignored) {
}
boolean isReset = serviceREST.resetPolicyCache(serviceName);
- Assert.assertEquals(res, isReset);
+ Assertions.assertEquals(res, isReset);
Mockito.verify(bizUtil).isAdmin();
Mockito.verify(bizUtil).isUserServiceAdmin(Mockito.any(RangerService.class), Mockito.anyString());
try {
@@ -2433,14 +2446,15 @@ public void test79ResetPolicyCacheWhenServiceNameIsInvalid() {
Mockito.when(svcStore.getServiceByName(serviceName)).thenReturn(null);
} catch (Exception ignored) {
}
- Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
- thrown.expect(WebApplicationException.class);
- serviceREST.resetPolicyCache(serviceName);
- Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.resetPolicyCache(serviceName);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ });
}
@Test
- public void test80GetPolicyByNameAndServiceNameWithZoneName() {
+ public void test80GetPolicyByNameAndServiceNameWithZoneName() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
RangerService rangerService = rangerService();
XXPolicy xxPolicy = new XXPolicy();
@@ -2453,14 +2467,14 @@ public void test80GetPolicyByNameAndServiceNameWithZoneName() {
Mockito.when(policyService.getPopulatedViewObject(xxPolicy)).thenReturn(rangerPolicy);
Mockito.when(bizUtil.isAdmin()).thenReturn(true);
RangerPolicy dbRangerPolicy = serviceREST.getPolicyByName(serviceName, policyName, zoneName);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
}
@Test
- public void test81GetPolicyByNameAndServiceNameWithZoneNameIsNull() {
+ public void test81GetPolicyByNameAndServiceNameWithZoneNameIsNull() throws Exception {
RangerPolicy rangerPolicy = rangerPolicy();
RangerService rangerService = rangerService();
XXPolicy xxPolicy = new XXPolicy();
@@ -2472,115 +2486,2002 @@ public void test81GetPolicyByNameAndServiceNameWithZoneNameIsNull() {
Mockito.when(policyService.getPopulatedViewObject(xxPolicy)).thenReturn(rangerPolicy);
Mockito.when(bizUtil.isAdmin()).thenReturn(true);
RangerPolicy dbRangerPolicy = serviceREST.getPolicyByName(serviceName, policyName, null);
- Assert.assertNotNull(dbRangerPolicy);
- Assert.assertEquals(dbRangerPolicy, rangerPolicy);
- Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
- Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assertions.assertNotNull(dbRangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assertions.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assertions.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
}
- RangerPolicy rangerPolicy() {
- List<RangerPolicyItemAccess> accesses = new ArrayList<>();
- List<String> users = new ArrayList<>();
- List<String> groups = new ArrayList<>();
- List<RangerPolicyItemCondition> conditions = new ArrayList<>();
- List<RangerPolicyItem> policyItems = new ArrayList<>();
- RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
- rangerPolicyItem.setAccesses(accesses);
- rangerPolicyItem.setConditions(conditions);
- rangerPolicyItem.setGroups(groups);
- rangerPolicyItem.setUsers(users);
- rangerPolicyItem.setDelegateAdmin(false);
+ @Test
+ public void test82GetServiceHeaders() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerServiceHeaderInfo serviceHeader = new RangerServiceHeaderInfo();
+ serviceHeader.setName("testService");
+ serviceHeader.setType("hdfs");
+ serviceHeader.setId(1L);
+
+ List<RangerServiceHeaderInfo> serviceHeaders = new ArrayList<>();
+ serviceHeaders.add(serviceHeader);
+
+ Mockito.when(request.getParameter(SearchFilter.SERVICE_NAME_PREFIX)).thenReturn("test");
+ Mockito.when(request.getParameter(SearchFilter.SERVICE_TYPE)).thenReturn("hdfs");
+ Mockito.when(daoManager.getXXService().findServiceHeaders()).thenReturn(serviceHeaders);
+ Mockito.when(bizUtil.hasAccess(Mockito.any(), Mockito.any())).thenReturn(true);
+
+ List<RangerServiceHeaderInfo> result = serviceREST.getServiceHeaders(request);
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(1, result.size());
+ Assertions.assertEquals("testService", result.get(0).getName());
+ Assertions.assertEquals("hdfs", result.get(0).getType());
+ }
- policyItems.add(rangerPolicyItem);
+ @Test
+ public void test83GetServiceHeadersWithFiltering() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerServiceHeaderInfo serviceHeader1 = new RangerServiceHeaderInfo();
+ serviceHeader1.setName("anotherService1");
+ serviceHeader1.setType("gds");
+ serviceHeader1.setId(1L);
+
+ RangerServiceHeaderInfo serviceHeader2 = new RangerServiceHeaderInfo();
+ serviceHeader2.setName("anotherService2");
+ serviceHeader2.setType("hdfs");
+ serviceHeader2.setId(2L);
+
+ RangerServiceHeaderInfo serviceHeader3 = new RangerServiceHeaderInfo();
+ serviceHeader3.setName("testService");
+ serviceHeader3.setType("hbase");
+ serviceHeader3.setId(3L);
+
+ RangerServiceHeaderInfo serviceHeader4 = new RangerServiceHeaderInfo();
+ serviceHeader4.setName("testService2");
+ serviceHeader4.setType("hdfs");
+ serviceHeader4.setId(4L);
+
+ List<RangerServiceHeaderInfo> serviceHeaders = new ArrayList<>();
+ serviceHeaders.add(serviceHeader1);
+ serviceHeaders.add(serviceHeader2);
+ serviceHeaders.add(serviceHeader3);
+ serviceHeaders.add(serviceHeader4);
+
+ Mockito.when(request.getParameter(SearchFilter.SERVICE_NAME_PREFIX)).thenReturn("test");
+ Mockito.when(request.getParameter(SearchFilter.SERVICE_TYPE)).thenReturn("hdfs");
+ Mockito.when(daoManager.getXXService().findServiceHeaders()).thenReturn(serviceHeaders);
+ Mockito.when(bizUtil.hasAccess(Mockito.any(), Mockito.any())).thenReturn(false);
+
+ List<RangerServiceHeaderInfo> result = serviceREST.getServiceHeaders(request);
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(0, result.size());
+ }
- Map<String, RangerPolicyResource> policyResource = new HashMap<>();
- RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
- rangerPolicyResource.setIsExcludes(true);
- rangerPolicyResource.setIsRecursive(true);
- rangerPolicyResource.setValue("1");
- rangerPolicyResource.setValues(users);
- policyResource.put("resource", rangerPolicyResource);
- RangerPolicy policy = new RangerPolicy();
- policy.setId(Id);
- policy.setCreateTime(new Date());
- policy.setDescription("policy");
- policy.setGuid("policyguid");
- policy.setIsEnabled(true);
- policy.setName("HDFS_1-1-20150316062453");
- policy.setUpdatedBy("Admin");
- policy.setUpdateTime(new Date());
- policy.setService("HDFS_1-1-20150316062453");
- policy.setIsAuditEnabled(true);
- policy.setPolicyItems(policyItems);
- policy.setResources(policyResource);
+ @Test
+ public void test84CheckSSO() throws Exception {
+ Mockito.when(bizUtil.isSSOEnabled()).thenReturn(true);
+ String result = serviceREST.checkSSO();
+ Assertions.assertEquals("true", result);
+
+ Mockito.when(bizUtil.isSSOEnabled()).thenReturn(false);
+ result = serviceREST.checkSSO();
+ Assertions.assertEquals("false", result);
+ }
- return policy;
+ @Test
+ public void test85GetCSRFProperties() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ HttpSession session = Mockito.mock(HttpSession.class);
+
+ Mockito.when(request.getSession()).thenReturn(session);
+ Mockito.when(session.getAttribute(Mockito.anyString())).thenReturn("test-salt");
+
+ HashMap<String, Object> result = serviceREST.getCSRFProperties(request);
+ Assertions.assertNotNull(result);
+ Assertions.assertTrue(result.containsKey("ranger.rest-csrf.enabled"));
+ Assertions.assertTrue(result.containsKey("ranger.rest-csrf.custom-header"));
+ Assertions.assertTrue(result.containsKey("ranger.rest-csrf.browser-useragents-regex"));
+ Assertions.assertTrue(result.containsKey("ranger.rest-csrf.methods-to-ignore"));
+ Assertions.assertTrue(result.containsKey("_csrfToken"));
}
- private List<Long> createLongList() {
- List<Long> list = new ArrayList<>();
- list.add(1L);
- list.add(2L);
- list.add(3L);
- return list;
+ @Test
+ public void test86InitStore_Success() {
+ serviceREST.initStore();
}
- private ArrayList<String> createUserList() {
- ArrayList<String> userList = new ArrayList<>();
- userList.add("test-user-1");
- return userList;
+ @Test
+ public void test87PurgeRecordsAuthSessions() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerPurgeResult> purgeResults = new ArrayList<>();
+ RangerPurgeResult purgeResult = new RangerPurgeResult();
+ purgeResult.setRecordType("login_records");
+ purgeResult.setTotalRecordCount(100L);
+ purgeResults.add(purgeResult);
+
+ Mockito.doNothing().when(svcStore).removeAuthSessions(Mockito.anyInt(), Mockito.any());
+
+ List<RangerPurgeResult> result = serviceREST.purgeRecords("login_records", 180, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(0, result.size());
+ Mockito.verify(svcStore, Mockito.times(1)).removeAuthSessions(Mockito.anyInt(), Mockito.any());
}
- private ArrayList<String> createGroupList() {
- ArrayList<String> groupList = new ArrayList<>();
- groupList.add("test-group-1");
- return groupList;
+ @Test
+ public void test88PurgeRecordsTransactionLogs() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerPurgeResult> purgeResults = new ArrayList<>();
+ RangerPurgeResult purgeResult = new RangerPurgeResult();
+ purgeResult.setRecordType("trx_records");
+ purgeResult.setTotalRecordCount(50L);
+ purgeResults.add(purgeResult);
+
+ Mockito.doNothing().when(svcStore).removeTransactionLogs(Mockito.anyInt(), Mockito.any());
+
+ List<RangerPurgeResult> result = serviceREST.purgeRecords("trx_records", 180, request);
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(0, result.size());
+ Mockito.verify(svcStore, Mockito.times(1)).removeTransactionLogs(Mockito.anyInt(), Mockito.any());
}
- private ArrayList<String> createRoleList() {
- ArrayList<String> roleList = new ArrayList<>();
- roleList.add("test-role-1");
- return roleList;
+ @Test
+ public void test89PurgeRecordsPolicyExportLogs() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerPurgeResult> purgeResults = new ArrayList<>();
+ RangerPurgeResult purgeResult = new RangerPurgeResult();
+ purgeResult.setRecordType("policy_export_logs");
+ purgeResult.setTotalRecordCount(25L);
+ purgeResults.add(purgeResult);
+
+ Mockito.doNothing().when(svcStore).removePolicyExportLogs(Mockito.anyInt(), Mockito.any());
+
+ List<RangerPurgeResult> result = serviceREST.purgeRecords("policy_export_logs", 180, request);
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(0, result.size());
+ Mockito.verify(svcStore, Mockito.times(1)).removePolicyExportLogs(Mockito.anyInt(), Mockito.any());
}
- private ArrayList<String> createGrantorGroupList() {
- ArrayList<String> grantorGroupList = new ArrayList<>();
- grantorGroupList.add("test-grantor-group-1");
- return grantorGroupList;
+ @Test
+ public void test90PurgeRecordsInvalidType() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String errorMessage = "invalid record type";
+
+ WebApplicationException webException = new WebApplicationException(new Throwable(errorMessage));
+ Mockito.when(restErrorUtil.createRESTException(
+ Mockito.eq(HttpServletResponse.SC_BAD_REQUEST),
+ Mockito.anyString(),
+ Mockito.eq(true))
+ ).thenReturn(webException);
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.purgeRecords("invalid_type", 180, request);
+ });
+
+ Assertions.assertNotNull(exception.getCause());
+ Assertions.assertEquals(errorMessage, exception.getCause().getMessage());
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
}
- private HashMap<String, String> createResourceMap() {
- HashMap<String, String> resourceMap = new HashMap<>();
- resourceMap.put("test-resource-1", "test-resource-value-1");
- return resourceMap;
+ @Test
+ public void test91PurgeRecordsInvalidRetentionDays() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String errorMessage = "Retention days can't be lesser than 1";
+
+ WebApplicationException webException = new WebApplicationException(new Throwable(errorMessage));
+
+ Mockito.when(restErrorUtil.createRESTException(
+ Mockito.eq(HttpServletResponse.SC_BAD_REQUEST),
+ Mockito.anyString(),
+ Mockito.eq(true))
+ ).thenReturn(webException);
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.purgeRecords("test-type", 0, request);
+ });
+
+ Assertions.assertNotNull(exception.getCause());
+ Assertions.assertEquals(errorMessage, exception.getCause().getMessage());
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
}
- private ArrayList<String> createAccessTypeList() {
- ArrayList<String> accessTypeList = new ArrayList<>();
- accessTypeList.add("test-access-type-1");
- return accessTypeList;
+ @Test
+ public void test92PurgeRecords_NullException() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String recordType = "login_records";
+ int olderThan = 180;
+
+ Mockito.doThrow(new RuntimeException("General exception")).when(svcStore).removeAuthSessions(Mockito.eq(olderThan), Mockito.anyList());
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ Assertions.assertThrows(WebApplicationException .class, () -> {
+ serviceREST.purgeRecords(recordType, olderThan, request);
+ });
+
+ Mockito.verify(svcStore).removeAuthSessions(Mockito.eq(olderThan), Mockito.anyList());
+ Mockito.verify(restErrorUtil).createRESTException("General exception");
}
- private GrantRevokeRequest createValidGrantRevokeRequest() {
- GrantRevokeRequest grantRevokeRequest = new GrantRevokeRequest();
- grantRevokeRequest.setUsers(new HashSet<>(createUserList()));
- grantRevokeRequest.setGroups(new HashSet<>(createGroupList()));
- grantRevokeRequest.setRoles(new HashSet<>(createRoleList()));
- grantRevokeRequest.setGrantor(grantor);
- grantRevokeRequest.setGrantorGroups(new HashSet<>(createGrantorGroupList()));
- grantRevokeRequest.setOwnerUser(ownerUser);
- grantRevokeRequest.setResource(createResourceMap());
- grantRevokeRequest.setAccessTypes(new HashSet<>(createAccessTypeList()));
- grantRevokeRequest.setZoneName(zoneName);
- grantRevokeRequest.setIsRecursive(true);
- return grantRevokeRequest;
+ @Test
+ public void test93GetBulkPolicies() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy policy1 = rangerPolicy();
+ RangerPolicy policy2 = rangerPolicy();
+ policy2.setId(2L);
+ policy2.setName("test-policy-2");
+
+ List<RangerPolicy> policies = Arrays.asList(policy1, policy2);
+ SearchFilter filter = new SearchFilter();
+
+ Mockito.when(searchUtil.getSearchFilter(Mockito.any(), Mockito.any())).thenReturn(filter);
+ Mockito.when(svcStore.getPolicies(filter)).thenReturn(policies);
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
+
+ Method method = ServiceREST.class.getDeclaredMethod("getBulkPolicies", String.class, HttpServletRequest.class);
+ method.setAccessible(true);
+ @SuppressWarnings("unchecked")
+ List<RangerPolicy> result = (List<RangerPolicy>) method.invoke(serviceREST, "HDFS_1-1-20150316062453", request);
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(2, result.size());
+ Assertions.assertEquals(policy1.getId(), result.get(0).getId());
+ Assertions.assertEquals(policy2.getId(), result.get(1).getId());
}
- private File getFile(String testFilePath) throws IOException {
- File jsonPolicyFile = new File(testFilePath);
- if (jsonPolicyFile.getCanonicalPath().contains("/target/jstest")) {
- jsonPolicyFile = new File(jsonPolicyFile.getCanonicalPath().replace("/target/jstest", ""));
- }
- return jsonPolicyFile;
+ @Test
+ public void test94GetBulkPolicies_WebApplicationException() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ Mockito.when(searchUtil.getSearchFilter(Mockito.any(), Mockito.any())).thenReturn(filter);
+ Mockito.when(svcStore.getPolicies(filter)).thenThrow(new WebApplicationException());
+
+ Method method = ServiceREST.class.getDeclaredMethod("getBulkPolicies", String.class, HttpServletRequest.class);
+ method.setAccessible(true);
+
+ InvocationTargetException exception = Assertions.assertThrows(InvocationTargetException.class, () -> {
+ method.invoke(serviceREST, "HDFS_1-1-20150316062453", request);
+ });
+ Assertions.assertTrue(exception.getCause() instanceof WebApplicationException);
+
+ Mockito.verify(svcStore).getPolicies(filter);
+ Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields);
+ }
+
+ @Test
+ public void test95GetBulkPolicies_Exception() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ Mockito.when(searchUtil.getSearchFilter(Mockito.any(), Mockito.any())).thenReturn(filter);
+ Mockito.when(svcStore.getPolicies(filter)).thenThrow(new RuntimeException("General exception"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ Method method = ServiceREST.class.getDeclaredMethod("getBulkPolicies", String.class, HttpServletRequest.class);
+ method.setAccessible(true);
+
+ InvocationTargetException exception = Assertions.assertThrows(InvocationTargetException.class, () -> {
+ method.invoke(serviceREST, "HDFS_1-1-20150316062453", request);
+ });
+ Assertions.assertTrue(exception.getCause() instanceof WebApplicationException);
+
+ Mockito.verify(svcStore).getPolicies(filter);
+ Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields);
+ Mockito.verify(restErrorUtil).createRESTException("General exception");
+ }
+
+ @Test
+ public void test96DeleteBulkPolicies() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy policy1 = rangerPolicy();
+ RangerPolicy policy2 = rangerPolicy();
+ policy2.setId(2L);
+ policy2.setName("test-policy-2");
+
+ Set<RangerPolicy> policies = new HashSet<>(Arrays.asList(policy1, policy2));
+ String serviceName = "test-service";
+
+ Mockito.when(searchUtil.getSearchFilter(Mockito.any(), Mockito.any())).thenReturn(new SearchFilter());
+ Mockito.when(svcStore.getPolicies(Mockito.any(SearchFilter.class))).thenReturn(new ArrayList<>(policies));
+ ServiceREST spyServiceRest = Mockito.spy(serviceREST);
+ XXServiceDao xxServiceDao = Mockito.mock(XXServiceDao.class);
+ Mockito.when(daoManager.getXXService()).thenReturn(xxServiceDao);
+ Mockito.when(xxServiceDao.findByName(Mockito.anyString())).thenReturn(xService());
+ Mockito.when(daoManager.getXXServiceDef().getById(Mockito.anyLong())).thenReturn(serviceDef());
+ RangerPolicyAdmin policyAdminMock = Mockito.mock(RangerPolicyAdmin.class);
+ Mockito.when(policyAdminMock.isDelegatedAdminAccessAllowedForRead(Mockito.any(), Mockito.anyString(), Mockito.anySet(), Mockito.anySet(), Mockito.anyMap())).thenReturn(true);
+ Mockito.when(policyAdminMock.getRolesFromUserAndGroups(Mockito.anyString(), Mockito.anySet())).thenReturn(new HashSet<>());
+ Mockito.when(policyAdminMock.isDelegatedAdminAccessAllowedForModify(Mockito.any(), Mockito.anyString(), Mockito.anySet(), Mockito.anySet(), Mockito.anyMap())).thenReturn(true);
+ Mockito.doReturn(policyAdminMock).when(spyServiceRest).getPolicyAdminForDelegatedAdmin(Mockito.anyString());
+ Mockito.when(userMgr.getGroupsForUser(Mockito.anyString())).thenReturn(new HashSet<>());
+ Mockito.when(bizUtil.getCurrentUserLoginId()).thenReturn("testUser");
+ Mockito.doNothing().when(svcStore).deletePolicies(Mockito.anySet(), Mockito.eq(serviceName), Mockito.anyList());
+
+ List<Long> result = spyServiceRest.deleteBulkPolicies(serviceName, request);
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(0, result.size());
+ Mockito.verify(svcStore, Mockito.times(1)).deletePolicies(Mockito.anySet(), Mockito.eq(serviceName), Mockito.anyList());
+ }
+
+ @Test
+ public void test97DeleteBulkPolicies_Exception() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy policy1 = rangerPolicy();
+ RangerPolicy policy2 = rangerPolicy();
+ policy2.setId(2L);
+ policy2.setName("test-policy-2");
+
+ Set<RangerPolicy> policies = new HashSet<>(Arrays.asList(policy1, policy2));
+ String serviceName = "test-service";
+
+ Mockito.when(searchUtil.getSearchFilter(Mockito.any(), Mockito.any())).thenReturn(new SearchFilter());
+ Mockito.when(svcStore.getPolicies(Mockito.any(SearchFilter.class))).thenReturn(new ArrayList<>(policies));
+ ServiceREST spyServiceRest = Mockito.spy(serviceREST);
+ XXServiceDao xxServiceDao = Mockito.mock(XXServiceDao.class);
+ Mockito.when(daoManager.getXXService()).thenReturn(xxServiceDao);
+ Mockito.when(xxServiceDao.findByName(Mockito.anyString())).thenReturn(xService());
+ Mockito.when(daoManager.getXXServiceDef().getById(Mockito.anyLong())).thenReturn(serviceDef());
+ RangerPolicyAdmin policyAdminMock = Mockito.mock(RangerPolicyAdmin.class);
+ Mockito.when(policyAdminMock.isDelegatedAdminAccessAllowedForRead(Mockito.any(), Mockito.anyString(), Mockito.anySet(), Mockito.anySet(), Mockito.anyMap())).thenReturn(true);
+ Mockito.when(policyAdminMock.getRolesFromUserAndGroups(Mockito.anyString(), Mockito.anySet())).thenReturn(new HashSet<>());
+ Mockito.when(policyAdminMock.isDelegatedAdminAccessAllowedForModify(Mockito.any(), Mockito.anyString(), Mockito.anySet(), Mockito.anySet(), Mockito.anyMap())).thenReturn(true);
+ Mockito.doReturn(policyAdminMock).when(spyServiceRest).getPolicyAdminForDelegatedAdmin(Mockito.anyString());
+ Mockito.when(userMgr.getGroupsForUser(Mockito.anyString())).thenReturn(new HashSet<>());
+ Mockito.when(bizUtil.getCurrentUserLoginId()).thenReturn("testUser");
+
+ Mockito.doThrow(new RuntimeException("General exception")).when(svcStore).deletePolicies(Mockito.anySet(), Mockito.eq(serviceName), Mockito.anyList());
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ spyServiceRest.deleteBulkPolicies(serviceName, request);
+ });
+
+ Mockito.verify(svcStore, Mockito.times(1)).deletePolicies(Mockito.anySet(), Mockito.eq(serviceName), Mockito.anyList());
+ }
+
+ @Test
+ public void test98GetPolicyResource() throws Exception {
+ GrantRevokeRequest grantRequest = createValidGrantRevokeRequest();
+
+ String resourceName = "test-resource";
+ RangerPolicyResource result = serviceREST.getPolicyResource(resourceName, grantRequest);
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(resourceName, result.getValues().get(0));
+
+ List<String> resourceList = Arrays.asList("resource1", "resource2");
+ result = serviceREST.getPolicyResource(resourceList, grantRequest);
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(2, result.getValues().size());
+ Assertions.assertTrue(result.getValues().contains("resource1"));
+ Assertions.assertTrue(result.getValues().contains("resource2"));
+ }
+
+ @Test
+ public void test99EnsureAdminAccessForServicePolicies() throws Exception {
+ RangerPolicy policy1 = rangerPolicy();
+ RangerPolicy policy2 = rangerPolicy();
+ policy2.setId(2L);
+ policy2.setName("test-policy-2");
+
+ Set<RangerPolicy> policies = new HashSet<>(Arrays.asList(policy1, policy2));
+ String serviceName = "HDFS";
+ XXService xxService = xService();
+
+ ServiceREST spyServiceRest = Mockito.spy(serviceREST);
+
+ Mockito.when(daoManager.getXXService().findByName(Mockito.anyString())).thenReturn(xxService);
+
+ XXServiceDef serviceDef = new XXServiceDef();
+ serviceDef.setImplclassname("test.impl.class");
+ Mockito.when(daoManager.getXXServiceDef().getById(Mockito.anyLong())).thenReturn(serviceDef);
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
+ Mockito.when(bizUtil.isKeyAdmin()).thenReturn(false);
+ Mockito.when(bizUtil.getCurrentUserLoginId()).thenReturn("testUser");
+ Mockito.when(userMgr.getGroupsForUser("testUser")).thenReturn(new HashSet<>());
+
+ RangerPolicyAdmin policyAdmin = Mockito.mock(RangerPolicyAdmin.class);
+ Mockito.when(spyServiceRest.getPolicyAdminForDelegatedAdmin(Mockito.anyString())).thenReturn(policyAdmin);
+ Mockito.when(policyAdmin.getRolesFromUserAndGroups(Mockito.anyString(), Mockito.anySet())).thenReturn(new HashSet<>());
+
+ Mockito.when(svcStore.isServiceAdminUser(Mockito.anyString(), Mockito.anyString())).thenReturn(false);
+
+ Method method = ServiceREST.class.getDeclaredMethod("ensureAdminAccessForServicePolicies", String.class, Set.class);
+ method.setAccessible(true);
+ method.invoke(spyServiceRest, serviceName, policies);
+
+ Mockito.verify(daoManager.getXXService()).findByName(serviceName);
+ }
+
+ @Test
+ public void test100EnsureAdminAccessForServicePoliciesNotFound() throws Exception {
+ Set<RangerPolicy> policies = new HashSet<>();
+ policies.add(rangerPolicy());
+ String serviceName = "non-existent-service";
+
+ Mockito.when(daoManager.getXXService().findByName(serviceName)).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ Method method = ServiceREST.class.getDeclaredMethod("ensureAdminAccessForServicePolicies", String.class, Set.class);
+ method.setAccessible(true);
+ InvocationTargetException exception = Assertions.assertThrows(InvocationTargetException.class, () -> {
+ method.invoke(serviceREST, serviceName, policies);
+ });
+ Assertions.assertTrue(exception.getCause() instanceof WebApplicationException);
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test101BlockIfGdsService() throws Exception {
+ String serviceName = "test-service";
+
+ Mockito.when(daoManager.getXXServiceDef().findServiceDefTypeByServiceName(serviceName)).thenReturn("gds");
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.blockIfGdsService(serviceName);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test102BlockIfGdsServiceNonGds() throws Exception {
+ String serviceName = "test-service";
+
+ Mockito.when(daoManager.getXXServiceDef().findServiceDefTypeByServiceName(serviceName)).thenReturn("hadoop");
+
+ Assertions.assertDoesNotThrow(() -> {
+ serviceREST.blockIfGdsService(serviceName);
+ });
+ }
+
+ @Test
+ public void test103GetPoliciesWithMetaAttributes() throws Exception {
+ RangerPolicy policy1 = rangerPolicy();
+ RangerPolicy policy2 = rangerPolicy();
+ policy2.setId(2L);
+ policy2.setName("test-policy-2");
+
+ List<RangerPolicy> policies = Arrays.asList(policy1, policy2);
+ List<RangerPolicy> expectedPolicies = Arrays.asList(policy1, policy2);
+
+ Mockito.when(svcStore.getPoliciesWithMetaAttributes(policies)).thenReturn(expectedPolicies);
+
+ List<RangerPolicy> result = serviceREST.getPoliciesWithMetaAttributes(policies);
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(2, result.size());
+ Assertions.assertEquals(policy1.getId(), result.get(0).getId());
+ Assertions.assertEquals(policy2.getId(), result.get(1).getId());
+ }
+
+ @Test
+ public void test104IsServiceAdmin() throws Exception {
+ String serviceName = "test-service";
+ String userName = "test-user";
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
+ boolean result = serviceREST.isServiceAdmin(serviceName);
+ Assertions.assertTrue(result);
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(false);
+ Mockito.when(bizUtil.getCurrentUserLoginId()).thenReturn(userName);
+ Mockito.when(svcStore.isServiceAdminUser(serviceName, userName)).thenReturn(true);
+ result = serviceREST.isServiceAdmin(serviceName);
+ Assertions.assertTrue(result);
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(false);
+ Mockito.when(svcStore.isServiceAdminUser(serviceName, userName)).thenReturn(false);
+ result = serviceREST.isServiceAdmin(serviceName);
+ Assertions.assertFalse(result);
+ }
+
+ @Test
+ public void test105hideCriticalServiceDetailsForRoleUser() throws Exception {
+ RangerService originalService = rangerService();
+ originalService.getConfigs().put("password", "secret");
+ originalService.getConfigs().put("username", "admin");
+ originalService.setDescription("Test service description");
+
+ // Use reflection to access the private method
+ Method method = ServiceREST.class.getDeclaredMethod("hideCriticalServiceDetailsForRoleUser", RangerService.class);
+ method.setAccessible(true);
+
+ RangerService result = (RangerService) method.invoke(serviceREST, originalService);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(result.getId(), originalService.getId());
+ Assertions.assertEquals(result.getName(), originalService.getName());
+ Assertions.assertEquals(result.getType(), originalService.getType());
+ Assertions.assertNull(result.getDescription());
+ Assertions.assertTrue(result.getConfigs().isEmpty());
+ }
+
+ @Test
+ public void test106LinkedServiceCreatorConstructor() throws Exception {
+ // Access the inner class using reflection
+ Class<?> linkedServiceCreatorClass = Class.forName("org.apache.ranger.rest.ServiceREST$LinkedServiceCreator");
+ Constructor<?> constructor = linkedServiceCreatorClass.getDeclaredConstructor(ServiceREST.class, String.class, String.class);
+ constructor.setAccessible(true);
+
+ Object linkedServiceCreator = constructor.newInstance(serviceREST, "testService", "tag");
+
+ // Access fields using reflection
+ Field resourceServiceNameField = linkedServiceCreatorClass.getDeclaredField("resourceServiceName");
+ Field linkedServiceTypeField = linkedServiceCreatorClass.getDeclaredField("linkedServiceType");
+ Field linkedServiceNameField = linkedServiceCreatorClass.getDeclaredField("linkedServiceName");
+ Field isAutoCreateField = linkedServiceCreatorClass.getDeclaredField("isAutoCreate");
+ Field isAutoLinkField = linkedServiceCreatorClass.getDeclaredField("isAutoLink");
+
+ resourceServiceNameField.setAccessible(true);
+ linkedServiceTypeField.setAccessible(true);
+ linkedServiceNameField.setAccessible(true);
+ isAutoCreateField.setAccessible(true);
+ isAutoLinkField.setAccessible(true);
+
+ String resourceServiceName = (String) resourceServiceNameField.get(linkedServiceCreator);
+ String linkedServiceType = (String) linkedServiceTypeField.get(linkedServiceCreator);
+ String linkedServiceName = (String) linkedServiceNameField.get(linkedServiceCreator);
+ Boolean isAutoCreate = (Boolean) isAutoCreateField.get(linkedServiceCreator);
+ Boolean isAutoLink = (Boolean) isAutoLinkField.get(linkedServiceCreator);
+
+ Assertions.assertEquals("testService", resourceServiceName);
+ Assertions.assertEquals("tag", linkedServiceType);
+ Assertions.assertTrue(isAutoCreate);
+ Assertions.assertTrue(isAutoLink);
+ }
+
+ @Test
+ public void test107LinkedServiceCreatorToString() throws Exception {
+ // Access the inner class using reflection
+ Class<?> linkedServiceCreatorClass = Class.forName("org.apache.ranger.rest.ServiceREST$LinkedServiceCreator");
+ Constructor<?> constructor = linkedServiceCreatorClass.getDeclaredConstructor(ServiceREST.class, String.class, String.class);
+ constructor.setAccessible(true);
+
+ Object linkedServiceCreator = constructor.newInstance(serviceREST, "testService", "tag");
+
+ String result = linkedServiceCreator.toString();
+
+ Assertions.assertNotNull(result);
+ Assertions.assertTrue(result.contains("resourceServiceName=testService"));
+ Assertions.assertTrue(result.contains("linkedServiceType=tag"));
+ Assertions.assertTrue(result.contains("isAutoCreate="));
+ Assertions.assertTrue(result.contains("isAutoLink="));
+ }
+
+ @Test
+ public void test108LinkedServiceCreatorDoCreateAndLinkService() throws Exception {
+ String testService = "testService";
+ RangerService existingService = rangerService();
+ existingService.setName(testService);
+
+ String linkedServiceType = "tag";
+
+ Class<?> linkedServiceCreatorClass = Class.forName("org.apache.ranger.rest.ServiceREST$LinkedServiceCreator");
+ Field sepField = linkedServiceCreatorClass.getDeclaredField("SEP");
+ sepField.setAccessible(true);
+ char sep = (char) sepField.get(null);
+
+ String linkedServiceName = testService + sep + linkedServiceType;
+ RangerService existingLinkedService = rangerService();
+ existingLinkedService.setName(linkedServiceName);
+ existingLinkedService.setType(linkedServiceType);
+
+ // Mock the service store to return existing service
+ Mockito.when(svcStore.getServiceByName(testService)).thenReturn(existingService);
+ Mockito.when(svcStore.getServiceByName(linkedServiceType)).thenReturn(null);
+ Mockito.when(svcStore.createService(Mockito.any(RangerService.class))).thenReturn(null);
+
+ // Access the inner class using reflection
+ //Class<?> linkedServiceCreatorClass = Class.forName("org.apache.ranger.rest.ServiceREST$LinkedServiceCreator");
+ Constructor<?> constructor = linkedServiceCreatorClass.getDeclaredConstructor(ServiceREST.class, String.class, String.class);
+ constructor.setAccessible(true);
+
+ Object linkedServiceCreator = constructor.newInstance(serviceREST, "testService", "tag");
+
+ // Access the doCreateAndLinkService method
+ Method doCreateAndLinkServiceMethod = linkedServiceCreatorClass.getDeclaredMethod("doCreateAndLinkService");
+ doCreateAndLinkServiceMethod.setAccessible(true);
+
+ // Execute the method
+ doCreateAndLinkServiceMethod.invoke(linkedServiceCreator);
+
+ Mockito.verify(svcStore, Mockito.times(2)).getServiceByName(testService);
+ Mockito.verify(svcStore, Mockito.times(2)).getServiceByName(linkedServiceType);
+ Mockito.verify(svcStore, Mockito.times(1)).createService(Mockito.any(RangerService.class));
+ }
+
+ @Test
+ public void test109GetPolicyByNameWithNullServiceName() throws Exception {
+ String serviceName = null;
+ String policyName = "testPolicy";
+ String zoneName = "testZone";
+
+ RangerPolicy rangerPolicy = serviceREST.getPolicyByName(serviceName, policyName, zoneName);
+
+ Assertions.assertNull(rangerPolicy); }
+
+ @Test
+ public void test110GetPolicyByNameWithNullPolicyName() throws Exception {
+ String serviceName = "testService";
+ String policyName = null;
+ String zoneName = "testZone";
+
+ RangerPolicy rangerPolicy = serviceREST.getPolicyByName(serviceName, policyName, zoneName);
+
+ Assertions.assertNull(rangerPolicy);
+ }
+
+ @Test
+ public void test111GetPolicyByNamePolicyNotFound() throws Exception {
+ String serviceName = "testService";
+ String policyName = "testPolicy";
+ String zoneName = "testZone";
+ XXPolicyDao xXPolicyDao = Mockito.mock(XXPolicyDao.class);
+
+ Mockito.when(daoManager.getXXPolicy()).thenReturn(xXPolicyDao);
+ Mockito.when(xXPolicyDao.findPolicy(policyName, serviceName, zoneName)).thenReturn(null);
+
+ RangerPolicy rangerPolicy = serviceREST.getPolicyByName(serviceName, policyName, zoneName);
+
+ Assertions.assertNull(rangerPolicy);
+ }
+
+ @Test
+ public void test112GetPolicyResourceWithNullResource() throws Exception {
+ GrantRevokeRequest grantRequest = createValidGrantRevokeRequest();
+
+ RangerPolicyResource result = serviceREST.getPolicyResource(null, grantRequest);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertNull(result.getValues().get(0));
+ }
+
+ @Test
+ public void test113GetPolicyResourceWithEmptyStringResource() throws Exception {
+ GrantRevokeRequest grantRequest = createValidGrantRevokeRequest();
+
+ RangerPolicyResource result = serviceREST.getPolicyResource("", grantRequest);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(1, result.getValues().size());
+ Assertions.assertEquals("", result.getValues().get(0));
+ }
+
+ @Test
+ public void test114CountServicesWithFilterException() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ Mockito.when(searchUtil.getSearchFilter(request, svcService.sortFields)).thenReturn(filter);
+ Mockito.when(svcStore.getPaginatedServices(filter)).thenThrow(new RuntimeException("Test exception"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.countServices(request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Test exception");
+ }
+
+ @Test
+ public void test115ValidateConfigWithException() throws Exception {
+ RangerService rangerService = rangerService();
+
+ Mockito.when(serviceMgr.validateConfig(rangerService, svcStore)).thenThrow(new RuntimeException("Validation failed"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.validateConfig(rangerService);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Validation failed");
+ }
+
+ @Test
+ public void test116LookupResourceWithException() throws Exception {
+ String serviceName = "HDFS_1";
+ ResourceLookupContext context = new ResourceLookupContext();
+ context.setResourceName(serviceName);
+ context.setUserInput("HDFS");
+
+ Mockito.when(serviceMgr.lookupResource(serviceName, context, svcStore)).thenThrow(new RuntimeException("Lookup failed"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.lookupResource(serviceName, context);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Lookup failed");
+ }
+
+ @Test
+ public void test117GetPluginsInfoWithException() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ Mockito.when(searchUtil.getSearchFilter(request, pluginInfoService.getSortFields())).thenReturn(filter);
+ Mockito.when(pluginInfoService.searchRangerPluginInfo(filter)).thenThrow(new RuntimeException("Search failed"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getPluginsInfo(request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Search failed");
+ }
+
+ @Test
+ public void test118GetMetricByTypeWithInvalidType() throws Exception {
+ String type = "invalid_type";
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getMetricByType(type);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void test119GetMetricByTypeWithException() throws Exception {
+ String type = "usergroup";
+
+ ServiceDBStore.METRIC_TYPE metricType = ServiceDBStore.METRIC_TYPE.getMetricTypeByName(type);
+ Mockito.when(svcStore.getMetricByType(metricType)).thenThrow(new RuntimeException("GetMetricByType failed"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getMetricByType(type);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void test120DeleteClusterServicesWithNoServices() throws Exception {
+ String clusterName = "emptyCluster";
+ List<Long> emptyList = new ArrayList<>();
+
+ Mockito.when(daoManager.getXXServiceConfigMap().findServiceIdsByClusterName(clusterName)).thenReturn(emptyList);
+
+ ResponseEntity<List<ServiceDeleteResponse>> result = serviceREST.deleteClusterServices(clusterName);
+
+ Assertions.assertEquals(HttpStatus.NOT_FOUND, result.getStatusCode());
+ Assertions.assertNotNull(result.getBody());
+ Assertions.assertTrue(result.getBody().isEmpty());
+ }
+
+ @Test
+ public void test121DeleteClusterServicesWithInvalidServices() throws Exception {
+ String clusterName = "invalidCluster";
+ List<Long> emptyList = new ArrayList<>();
+
+ Mockito.when(daoManager.getXXServiceConfigMap().findServiceIdsByClusterName(clusterName)).thenThrow(new RuntimeException("Search Config failed"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.deleteClusterServices(clusterName);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void test122DeleteClusterServicesWithException() throws Exception {
+ String clusterName = "testCluster";
+ List<Long> serviceIds = Arrays.asList(1L, 2L, 3L);
+
+ Mockito.when(daoManager.getXXServiceConfigMap().findServiceIdsByClusterName(clusterName)).thenReturn(serviceIds);
+ Mockito.when(daoManager.getXXService().getById(Mockito.anyLong())).thenThrow(new RuntimeException("Database error"));
+
+ ResponseEntity<List<ServiceDeleteResponse>> result = serviceREST.deleteClusterServices(clusterName);
+
+ Assertions.assertEquals(HttpStatus.OK, result.getStatusCode());
+ Assertions.assertNotNull(result.getBody());
+ Assertions.assertEquals(3, result.getBody().size());
+ for (ServiceDeleteResponse response : result.getBody()) {
+ Assertions.assertFalse(response.getIsDeleted());
+ }
+ }
+
+ @Test
+ public void test123IsServiceAdminWithNullServiceName() throws Exception {
+ String serviceName = null;
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(false);
+
+ boolean result = serviceREST.isServiceAdmin(serviceName);
+
+ Assertions.assertFalse(result);
+ Mockito.verify(bizUtil).isAdmin();
+ }
+
+ @Test
+ public void test124IsServiceAdminWithEmptyServiceName() throws Exception {
+ String serviceName = "";
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(false);
+
+ boolean result = serviceREST.isServiceAdmin(serviceName);
+
+ Assertions.assertFalse(result);
+ Mockito.verify(bizUtil).isAdmin();
+ }
+
+ @Test
+ public void test125GetServiceDefWithAccessDenied() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ XXServiceDef xServiceDef = serviceDef();
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.getById(Id)).thenReturn(xServiceDef);
+ Mockito.when(bizUtil.hasAccess(xServiceDef, null)).thenReturn(false);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class))).thenThrow(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getServiceDef(rangerServiceDef.getId());
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class));
+ }
+
+ @Test
+ public void test126CreateServiceWithDisplayNameHandling() throws Exception {
+ RangerService service = rangerService();
+ service.setDisplayName(null); // Test null display name
+ XXServiceDef xServiceDef = serviceDef();
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(validatorFactory.getServiceValidator(svcStore)).thenReturn(serviceValidator);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(service.getType())).thenReturn(xServiceDef);
+ Mockito.when(svcStore.createService(Mockito.any())).thenReturn(service);
+
+ RangerService result = serviceREST.createService(service);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(service.getName(), service.getDisplayName()); // Should use name as display name
+ Mockito.verify(svcStore).createService(Mockito.any(RangerService.class));
+ }
+
+ @Test
+ public void test127CreateServiceWithBlankDisplayName() throws Exception {
+ RangerService service = rangerService();
+ service.setDisplayName(" "); // Test blank display name
+ XXServiceDef xServiceDef = serviceDef();
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(validatorFactory.getServiceValidator(svcStore)).thenReturn(serviceValidator);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(service.getType())).thenReturn(xServiceDef);
+ Mockito.when(svcStore.createService(Mockito.any())).thenReturn(service);
+
+ RangerService result = serviceREST.createService(service);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(service.getName(), service.getDisplayName()); // Should use name as display name
+ Mockito.verify(svcStore).createService(Mockito.any(RangerService.class));
+ }
+
+ @Test
+ public void test128CreateServiceDefWithValidationFailure() throws Exception {
+ RangerServiceDef serviceDef = rangerServiceDef();
+
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore)).thenThrow(new RuntimeException("Validation failed"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.createServiceDef(serviceDef);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Validation failed");
+ }
+
+ @Test
+ public void test129UpdateServiceWithValidationFailure() throws Exception {
+ RangerService service = rangerService();
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ XXServiceDef xServiceDef = serviceDef();
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(validatorFactory.getServiceValidator(svcStore)).thenThrow(new RuntimeException("Validation failed"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.updateService(service, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Validation failed");
+ }
+
+ @Test
+ public void test130GetServiceDefByNameNotFound() throws Exception {
+ String serviceName = "nonexistent";
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(serviceName)).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getServiceDefByName(serviceName);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test131GetServiceByNameNotFound() throws Exception {
+ String serviceName = "nonexistent";
+
+ Mockito.when(svcStore.getServiceByName(serviceName)).thenThrow(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getServiceByName(serviceName);
+ });
+
+ Mockito.verify(svcStore).getServiceByName(serviceName);
+ }
+
+ @Test
+ public void test132GetServiceNotFound() throws Exception {
+ Long serviceId = 999L;
+
+ Mockito.when(svcStore.getService(serviceId)).thenThrow(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getService(serviceId);
+ });
+
+ Mockito.verify(svcStore).getService(serviceId);
+ }
+
+ @Test
+ public void test133PurgeEmptyPoliciesWithNullServiceName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.purgeEmptyPolicies(null, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test134PurgeEmptyPoliciesServiceNotFound() throws Exception {
+ String serviceName = "nonexistent";
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.when(svcStore.getServiceByName(serviceName)).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.purgeEmptyPolicies(serviceName, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void test135GetPolicyFromEventTimeWithMissingParameters() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.when(request.getParameter("eventTime")).thenReturn(null);
+ Mockito.when(request.getParameter("policyId")).thenReturn("1");
+ Mockito.when(request.getParameter("versionNo")).thenReturn("1");
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class))).thenThrow(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getPolicyFromEventTime(request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class));
+ }
+
+ @Test
+ public void test136GetServicePoliciesIfUpdatedWithInvalidService() throws Exception {
+ String serviceName = "invalid";
+ Long lastKnownVersion = 1L;
+ String pluginId = "test";
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.when(serviceUtil.isValidateHttpsAuthentication(serviceName, request)).thenReturn(true);
+ Mockito.when(svcStore.getServicePoliciesIfUpdated(serviceName, lastKnownVersion, false))
+ .thenThrow(new RuntimeException("Service not found"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getServicePoliciesIfUpdated(serviceName, lastKnownVersion, 0L, pluginId, "", "", false, capabilityVector, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test137GetServiceDefsWithFilterException() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ Mockito.when(searchUtil.getSearchFilter(request, serviceDefService.sortFields)).thenReturn(filter);
+ Mockito.when(bizUtil.hasModuleAccess(RangerConstants.MODULE_RESOURCE_BASED_POLICIES)).thenReturn(true);
+ Mockito.when(svcStore.getPaginatedServiceDefs(filter)).thenThrow(new RuntimeException("Database error"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getServiceDefs(request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Database error");
+ }
+
+ @Test
+ public void test138GetServiceDefsWithoutModuleAccess() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.when(bizUtil.hasModuleAccess(RangerConstants.MODULE_RESOURCE_BASED_POLICIES)).thenReturn(false);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getServiceDefs(request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test139CreatePolicyWithNameTrimming() throws Exception {
+ RangerPolicy policy = rangerPolicy();
+ policy.setName(" policy-with-spaces ");
+ policy.setDescription(" description-with-spaces ");
+ XXServiceDef xServiceDef = serviceDef();
+ XXService xService = xService();
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+
+ Mockito.when(validatorFactory.getPolicyValidator(svcStore)).thenReturn(policyValidator);
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
+ Mockito.when(bizUtil.getCurrentUserLoginId()).thenReturn("admin");
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(Mockito.anyString())).thenReturn(xService);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+ Mockito.when(svcStore.createPolicy(Mockito.any())).thenReturn(policy);
+
+ RangerPolicy result = serviceREST.createPolicy(policy, null);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals("policy-with-spaces", policy.getName().trim());
+ Assertions.assertEquals("description-with-spaces", policy.getDescription().trim());
+ Mockito.verify(svcStore).createPolicy(Mockito.any(RangerPolicy.class));
+ }
+
+ @Test
+ public void test140CreatePolicyWithLongName() throws Exception {
+ RangerPolicy policy = rangerPolicy();
+ // Create a name longer than maxPolicyNameLength (255)
+ StringBuilder longName = new StringBuilder();
+ for (int i = 0; i < 300; i++) {
+ longName.append("a");
+ }
+ policy.setName(longName.toString());
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class), Mockito.isNull(), Mockito.anyString(), Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.createPolicy(policy, null);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class), Mockito.isNull(), Mockito.anyString(), Mockito.anyString());
+ }
+
+ @Test
+ public void test141UpdateServiceWithNameTrimming() throws Exception {
+ RangerService service = rangerService();
+ service.setName(" service-with-spaces ");
+ service.setDisplayName(" display-name-with-spaces ");
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ XXServiceDef xServiceDef = serviceDef();
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(validatorFactory.getServiceValidator(svcStore)).thenReturn(serviceValidator);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(service.getType())).thenReturn(xServiceDef);
+ Mockito.when(svcStore.updateService(Mockito.any(), Mockito.any())).thenReturn(service);
+
+ RangerService result = serviceREST.updateService(service, request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals("service-with-spaces", service.getName().trim());
+ Assertions.assertEquals("display-name-with-spaces", service.getDisplayName().trim());
+ Mockito.verify(svcStore).updateService(Mockito.any(RangerService.class), Mockito.any());
+ }
+
+ @Test
+ public void test142GetPoliciesForResourceWithInvalidServiceDef() throws Exception {
+ String serviceDefName = "invalid";
+ String serviceName = "testService";
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class))).thenThrow(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getPoliciesForResource(serviceDefName, serviceName, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class));
+ }
+
+ @Test
+ public void test143DeleteServiceDefNotFound() throws Exception {
+ Long serviceDefId = 999L;
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore)).thenReturn(serviceDefValidator);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.getById(serviceDefId)).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.deleteServiceDef(serviceDefId, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+ }
+
+ @Test
+ public void test144GetServiceByIdNotFound() throws Exception {
+ Long serviceId = 999L;
+
+ Mockito.when(svcStore.getService(serviceId)).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getService(serviceId);
+ });
+
+ Mockito.verify(svcStore).getService(serviceId);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test145ResetPolicyCacheWithException() throws Exception {
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class))).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.resetPolicyCache(null);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class));
+ }
+
+ @Test
+ public void test146ResetPolicyCacheAllWithException() throws Exception {
+ Mockito.when(bizUtil.isAdmin()).thenReturn(false);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class))).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.resetPolicyCacheAll();
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), Mockito.any(MessageEnums.class));
+ }
+
+ @Test
+ public void test147GetServicePoliciesByNameWithException() throws Exception {
+ String serviceName = "testService";
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ Mockito.when(searchUtil.getSearchFilter(request, policyService.sortFields)).thenReturn(filter);
+ Mockito.when(svcStore.getServicePolicies(serviceName, filter)).thenThrow(new RuntimeException("Service not found"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getServicePoliciesByName(serviceName, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Service not found");
+ }
+
+ @Test
+ public void test148GetServicePoliciesByIdWithException() throws Exception {
+ Long serviceId = 1L;
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ Mockito.when(searchUtil.getSearchFilter(request, policyService.sortFields)).thenReturn(filter);
+ Mockito.when(svcStore.getServicePolicies(serviceId, filter)).thenThrow(new RuntimeException("Service not found"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getServicePolicies(serviceId, request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Service not found");
+ }
+
+ @Test
+ public void test149CheckSSOWithDifferentValues() throws Exception {
+ Mockito.when(bizUtil.isSSOEnabled()).thenReturn(true);
+ String result = serviceREST.checkSSO();
+ Assertions.assertEquals("true", result);
+
+ Mockito.reset(bizUtil);
+ Mockito.when(bizUtil.isSSOEnabled()).thenReturn(false);
+ result = serviceREST.checkSSO();
+ Assertions.assertEquals("false", result);
+ }
+
+ @Test
+ public void test150GetCSRFPropertiesWithNullSession() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ HttpSession session = Mockito.mock(HttpSession.class);
+
+ Mockito.when(request.getSession()).thenReturn(session);
+ Mockito.when(session.getAttribute(Mockito.anyString())).thenReturn(null);
+
+ HashMap<String, Object> result = serviceREST.getCSRFProperties(request);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertTrue(result.containsKey("ranger.rest-csrf.enabled"));
+ Assertions.assertTrue(result.containsKey("_csrfToken"));
+ Assertions.assertNotNull(result.get("_csrfToken"));
+ }
+
+ @Test
+ public void test151ApplyPolicyWithNullRequest() throws Exception {
+ RangerPolicy policy = rangerPolicy();
+
+ ServiceREST serviceRESTSpy = Mockito.spy(serviceREST);
+ Mockito.doReturn(policy).when(serviceRESTSpy).createPolicy(Mockito.any(RangerPolicy.class), eq(null));
+
+ RangerPolicy result = serviceRESTSpy.applyPolicy(policy, null);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals(policy.getId(), result.getId());
+ Mockito.verify(serviceRESTSpy).createPolicy(policy, null);
+ }
+
+ @Test
+ public void test152GetPolicyLabelsWithException() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+
+ Mockito.when(searchUtil.getSearchFilter(request, policyLabelsService.sortFields)).thenReturn(filter);
+ Mockito.when(svcStore.getPolicyLabels(filter)).thenThrow(new RuntimeException("Database error"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getPolicyLabels(request);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Database error");
+ }
+
+ @Test
+ public void test153GetServiceWithRoleUserAndException() throws Exception {
+ Long serviceId = 1L;
+
+ Mockito.when(svcStore.getService(serviceId)).thenThrow(new RuntimeException("Service not found"));
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getService(serviceId);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException("Service not found");
+ Mockito.verify(svcStore).getService(serviceId);
+ }
+
+ @Test
+ public void test154GetPolicyForVersionNumberWithAccessDenied() throws Exception {
+ Long policyId = 1L;
+ int versionNo = 1;
+ RangerPolicy policy = rangerPolicy();
+
+ Mockito.when(svcStore.getPolicyForVersionNumber(policyId, versionNo)).thenReturn(policy);
+ Mockito.when(bizUtil.isAdmin()).thenReturn(false);
+ Mockito.when(bizUtil.getCurrentUserLoginId()).thenReturn("user");
+ Mockito.when(svcStore.isServiceAdminUser(policy.getService(), "user")).thenReturn(false);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean()))
+ .thenReturn(new WebApplicationException());
+
+ WebApplicationException exception = Assertions.assertThrows(WebApplicationException.class, () -> {
+ serviceREST.getPolicyForVersionNumber(policyId, versionNo);
+ });
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ RangerPolicy rangerPolicy() {
+ List<RangerPolicyItemAccess> accesses = new ArrayList<>();
+ List<String> users = new ArrayList<>();
+ List<String> groups = new ArrayList<>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<>();
+ List<RangerPolicyItem> policyItems = new ArrayList<>();
+ RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
+ rangerPolicyItem.setAccesses(accesses);
+ rangerPolicyItem.setConditions(conditions);
+ rangerPolicyItem.setGroups(groups);
+ rangerPolicyItem.setUsers(users);
+ rangerPolicyItem.setDelegateAdmin(false);
+
+ policyItems.add(rangerPolicyItem);
+
+ Map<String, RangerPolicyResource> policyResource = new HashMap<>();
+ RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
+ rangerPolicyResource.setIsExcludes(true);
+ rangerPolicyResource.setIsRecursive(true);
+ rangerPolicyResource.setValue("1");
+ rangerPolicyResource.setValues(users);
+ policyResource.put("resource", rangerPolicyResource);
+ RangerPolicy policy = new RangerPolicy();
+ policy.setId(Id);
+ policy.setCreateTime(new Date());
+ policy.setDescription("policy");
+ policy.setGuid("policyguid");
+ policy.setIsEnabled(true);
+ policy.setName("HDFS_1-1-20150316062453");
+ policy.setUpdatedBy("Admin");
+ policy.setUpdateTime(new Date());
+ policy.setService("HDFS_1-1-20150316062453");
+ policy.setIsAuditEnabled(true);
+ policy.setPolicyItems(policyItems);
+ policy.setResources(policyResource);
+
+ return policy;
+ }
+
+ private List<Long> createLongList() {
+ List<Long> list = new ArrayList<>();
+ list.add(1L);
+ list.add(2L);
+ list.add(3L);
+ return list;
+ }
+
+ private ArrayList<String> createUserList() {
+ ArrayList<String> userList = new ArrayList<>();
+ userList.add("test-user-1");
+ return userList;
+ }
+
+ private ArrayList<String> createGroupList() {
+ ArrayList<String> groupList = new ArrayList<>();
+ groupList.add("test-group-1");
+ return groupList;
+ }
+
+ private ArrayList<String> createRoleList() {
+ ArrayList<String> roleList = new ArrayList<>();
+ roleList.add("test-role-1");
+ return roleList;
+ }
+
+ private ArrayList<String> createGrantorGroupList() {
+ ArrayList<String> grantorGroupList = new ArrayList<>();
+ grantorGroupList.add("test-grantor-group-1");
+ return grantorGroupList;
+ }
+
+ private HashMap<String, String> createResourceMap() {
+ HashMap<String, String> resourceMap = new HashMap<>();
+ resourceMap.put("test-resource-1", "test-resource-value-1");
+ return resourceMap;
+ }
+
+ private ArrayList<String> createAccessTypeList() {
+ ArrayList<String> accessTypeList = new ArrayList<>();
+ accessTypeList.add("test-access-type-1");
+ return accessTypeList;
+ }
+
+ private GrantRevokeRequest createValidGrantRevokeRequest() {
+ GrantRevokeRequest grantRevokeRequest = new GrantRevokeRequest();
+ grantRevokeRequest.setUsers(new HashSet<>(createUserList()));
+ grantRevokeRequest.setGroups(new HashSet<>(createGroupList()));
+ grantRevokeRequest.setRoles(new HashSet<>(createRoleList()));
+ grantRevokeRequest.setGrantor(grantor);
+ grantRevokeRequest.setGrantorGroups(new HashSet<>(createGrantorGroupList()));
+ grantRevokeRequest.setOwnerUser(ownerUser);
+ grantRevokeRequest.setResource(createResourceMap());
+ grantRevokeRequest.setAccessTypes(new HashSet<>(createAccessTypeList()));
+ grantRevokeRequest.setZoneName(zoneName);
+ grantRevokeRequest.setIsRecursive(true);
+ return grantRevokeRequest;
+ }
+
+ private XXPolicy getXXPolicy() {
+ XXPolicy xxPolicy = new XXPolicy();
+ xxPolicy.setId(Id);
+ xxPolicy.setName("HDFS_1-1-20150316062453");
+ xxPolicy.setAddedByUserId(Id);
+ xxPolicy.setDescription("policy");
+ xxPolicy.setGuid("policyguid");
+ xxPolicy.setCreateTime(new Date());
+ xxPolicy.setIsAuditEnabled(true);
+ xxPolicy.setIsEnabled(true);
+ xxPolicy.setService(1L);
+ xxPolicy.setUpdatedByUserId(Id);
+ xxPolicy.setUpdateTime(new Date());
+ return xxPolicy;
+ }
+
+ private File getFile(String testFilePath) throws IOException {
+ File jsonPolicyFile = new File(testFilePath);
+ if (jsonPolicyFile.getCanonicalPath().contains("/target/jstest")) {
+ jsonPolicyFile = new File(jsonPolicyFile.getCanonicalPath().replace("/target/jstest", ""));
+ }
+ return jsonPolicyFile;
+ }
+
+ @Test
+ public void testGetAccessResourceObjectMap_NullMap() {
+ Map<String, Object> result = ServiceREST.getAccessResourceObjectMap(null);
+ Assertions.assertNull(result);
+ }
+
+ @Test
+ public void testGetAccessResourceObjectMap_SingleValues() {
+ Map<String, String> input = new HashMap<>();
+ input.put("database", "db1");
+ input.put("table", "tbl1");
+
+ Map<String, Object> result = ServiceREST.getAccessResourceObjectMap(input);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertEquals("db1", result.get("database"));
+ Assertions.assertEquals("tbl1", result.get("table"));
+ }
+
+ @Test
+ public void testGetAccessResourceObjectMap_CommaSeparatedValues() {
+ Map<String, String> input = new HashMap<>();
+ input.put("column", "c1,c2,c3");
+
+ Map<String, Object> result = ServiceREST.getAccessResourceObjectMap(input);
+
+ Assertions.assertNotNull(result);
+ Assertions.assertTrue(result.get("column") instanceof List);
+ @SuppressWarnings("unchecked")
+ List<String> cols = (List<String>) result.get("column");
+ Assertions.assertEquals(Arrays.asList("c1", "c2", "c3"), cols);
+ }
+
+ @Test
+ public void testGetPolicyComparator_ByIdDesc_And_ByNameAscDesc() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("getPolicyComparator", String.class, String.class);
+ m.setAccessible(true);
+
+ RangerPolicy p1 = rangerPolicy();
+ p1.setId(1L);
+ p1.setName("A");
+ RangerPolicy p2 = rangerPolicy();
+ p2.setId(2L);
+ p2.setName("B");
+
+ @SuppressWarnings("unchecked")
+ Comparator<RangerPolicy> byIdDesc = (Comparator<RangerPolicy>) m.invoke(serviceREST, SearchFilter.POLICY_ID, "DESC");
+ Assertions.assertTrue(byIdDesc.compare(p1, p2) > 0);
+
+ @SuppressWarnings("unchecked")
+ Comparator<RangerPolicy> byNameAsc = (Comparator<RangerPolicy>) m.invoke(serviceREST, SearchFilter.POLICY_NAME, "ASC");
+ Assertions.assertTrue(byNameAsc.compare(p1, p2) < 0);
+
+ @SuppressWarnings("unchecked")
+ Comparator<RangerPolicy> byNameDesc = (Comparator<RangerPolicy>) m.invoke(serviceREST, SearchFilter.POLICY_NAME, "DESC");
+ Assertions.assertTrue(byNameDesc.compare(p1, p2) > 0);
+ }
+
+ @Test
+ public void testGetPolicyAdminForSearch_DoesNotThrow() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("getPolicyAdminForSearch", String.class);
+ m.setAccessible(true);
+ Assertions.assertDoesNotThrow(() -> {
+ try {
+ m.invoke(serviceREST, "svc");
+ } catch (InvocationTargetException ite) {
+ throw new RuntimeException(ite.getCause());
+ }
+ });
+ }
+
+ @Test
+ public void testIsZoneAdmin() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("isZoneAdmin", String.class);
+ m.setAccessible(true);
+ Mockito.when(bizUtil.isAdmin()).thenReturn(false);
+ Mockito.when(serviceMgr.isZoneAdmin("zone1")).thenReturn(true);
+ boolean ret = (boolean) m.invoke(serviceREST, "zone1");
+ Assertions.assertTrue(ret);
+ }
+
+ @Test
+ public void testHasAdminAccess_Resource_Allowed() throws Exception {
+ ServiceREST spy = Mockito.spy(serviceREST);
+ Method m = ServiceREST.class.getDeclaredMethod("hasAdminAccess", String.class, String.class, String.class, Set.class, RangerAccessResource.class, Set.class);
+ m.setAccessible(true);
+ RangerPolicyAdmin policyAdmin = Mockito.mock(RangerPolicyAdmin.class);
+ Mockito.doReturn(policyAdmin).when(spy).getPolicyAdminForDelegatedAdmin(Mockito.anyString());
+ Mockito.when(policyAdmin.isDelegatedAdminAccessAllowed(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.anySet(), Mockito.anySet())).thenReturn(true);
+ RangerAccessResource resource = new RangerAccessResourceImpl(Collections.singletonMap("path", "/"));
+ boolean ret = (boolean) m.invoke(spy, "svc", "zone", "user", new HashSet<>(), resource, Collections.singleton("admin"));
+ Assertions.assertTrue(ret);
+ }
+
+ @Test
+ public void testHasAdminAccess_Policy_Allowed() throws Exception {
+ ServiceREST spy = Mockito.spy(serviceREST);
+ Method m = ServiceREST.class.getDeclaredMethod("hasAdminAccess", RangerPolicy.class, String.class, Set.class);
+ m.setAccessible(true);
+ RangerPolicyAdmin policyAdmin = Mockito.mock(RangerPolicyAdmin.class);
+ Mockito.doReturn(policyAdmin).when(spy).getPolicyAdminForDelegatedAdmin(Mockito.anyString());
+ Mockito.when(policyAdmin.getRolesFromUserAndGroups(Mockito.anyString(), Mockito.anySet())).thenReturn(new HashSet<>());
+ Mockito.when(policyAdmin.isDelegatedAdminAccessAllowedForModify(Mockito.any(), Mockito.anyString(), Mockito.anySet(), Mockito.anySet(), Mockito.anyMap())).thenReturn(true);
+ RangerPolicy policy = rangerPolicy();
+ boolean ret = (boolean) m.invoke(spy, policy, "user", new HashSet<>());
+ Assertions.assertTrue(ret);
+ }
+
+ @Test
+ public void testProcessServiceMapping_ValidAndInvalid() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("processServiceMapping", Map.class, List.class, List.class);
+ m.setAccessible(true);
+ Map<String, String> map = new HashMap<>();
+ map.put(" s ", " d ");
+ List<String> src = new ArrayList<>();
+ List<String> dst = new ArrayList<>();
+ m.invoke(serviceREST, map, src, dst);
+ Assertions.assertEquals(1, src.size());
+ Assertions.assertEquals(1, dst.size());
+
+ map.put(" ", " ");
+ Assertions.assertThrows(InvocationTargetException.class, () -> m.invoke(serviceREST, map, new ArrayList<>(), new ArrayList<>()));
+ }
+
+ @Test
+ public void testDeleteExactMatchPolicyForResource_DeletesWhenMatchFound() throws Exception {
+ ServiceREST spy = Mockito.spy(serviceREST);
+ Method m = ServiceREST.class.getDeclaredMethod("deleteExactMatchPolicyForResource", List.class, String.class, String.class);
+ m.setAccessible(true);
+ RangerPolicy toDelete = rangerPolicy();
+ m.invoke(spy, Collections.singletonList(toDelete), "user", null);
+ Mockito.verify(svcStore, Mockito.never()).deletePolicy(Mockito.any(), Mockito.isNull());
+ }
+
+ @Test
+ public void testGetPolicyMatchByName_UsesRequestParams() throws Exception {
+ ServiceREST spy = Mockito.spy(serviceREST);
+ Method m = ServiceREST.class.getDeclaredMethod("getPolicyMatchByName", RangerPolicy.class, HttpServletRequest.class);
+ m.setAccessible(true);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Mockito.when(request.getParameter("servicename")).thenReturn("svc1");
+ Mockito.when(request.getParameter("policyname")).thenReturn("pol1");
+ Mockito.when(request.getParameter("zoneName")).thenReturn("zone1");
+ RangerPolicy expected = rangerPolicy();
+ Mockito.doReturn(expected).when(spy).getPolicyByName("svc1", "pol1", "zone1");
+ RangerPolicy actual = (RangerPolicy) m.invoke(spy, new RangerPolicy(), request);
+ Assertions.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void testGetExactMatchPolicyForResource_ReturnsNullWhenNoAdmin() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("getExactMatchPolicyForResource", RangerPolicy.class, String.class);
+ m.setAccessible(true);
+ RangerPolicy policy = rangerPolicy();
+ Assertions.assertDoesNotThrow(() -> {
+ try {
+ m.invoke(serviceREST, policy, "user");
+ } catch (InvocationTargetException ite) {
+ throw new RuntimeException(ite.getCause());
+ }
+ });
+ }
+
+ @Test
+ public void testDeletePoliciesForResource_DeletesNonExported() throws Exception {
+ ServiceREST spy = Mockito.spy(serviceREST);
+ Method m = ServiceREST.class.getDeclaredMethod("deletePoliciesForResource", List.class, List.class, HttpServletRequest.class, List.class, String.class);
+ m.setAccessible(true);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+ Mockito.when(searchUtil.getSearchFilter(Mockito.any(), Mockito.any())).thenReturn(filter);
+ RangerPolicy p = rangerPolicy();
+ p.setName("to-delete");
+ RangerPolicyList list = new RangerPolicyList();
+ list.setPolicies(Collections.singletonList(p));
+ // Cannot mock private getServicePolicies; instead, we only verify path runs without exception
+ Mockito.doReturn(rangerService()).when(spy).getServiceByName("dest");
+ Assertions.assertDoesNotThrow(() -> m.invoke(spy, Collections.singletonList("src"), Collections.singletonList("dest"), request, Collections.emptyList(), ""));
+ }
+
+ @Test
+ public void testValidateResourcePoliciesRequest_NoResource_And_InvalidServiceType() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("validateResourcePoliciesRequest", String.class, String.class, HttpServletRequest.class, List.class, Map.class);
+ m.setAccessible(true);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ @SuppressWarnings("unchecked")
+ String msg = (String) m.invoke(serviceREST, "hdfs", "svc", request, new ArrayList<>(), new HashMap<>());
+ Assertions.assertTrue(msg.contains("No resource"));
+
+ Map<String, Object> resource = new HashMap<>();
+ resource.put("db", "db1");
+ Mockito.when(svcStore.getServiceDefByName("badType")).thenReturn(null);
+ msg = (String) m.invoke(serviceREST, "badType", "svc", request, new ArrayList<>(), resource);
+ Assertions.assertTrue(msg.contains("Invalid service-type"));
+ }
+
+ @Test
+ public void testValidateUsersGroupsAndRoles_Empty_Throws() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("validateUsersGroupsAndRoles", Set.class, Set.class, Set.class);
+ m.setAccessible(true);
+ Mockito.when(restErrorUtil.createGrantRevokeRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(InvocationTargetException.class, () -> m.invoke(serviceREST, Collections.emptySet(), Collections.emptySet(), Collections.emptySet()));
+ }
+
+ @Test
+ public void testValidateGrantor_NotExists_Throws() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("validateGrantor", String.class);
+ m.setAccessible(true);
+ Mockito.when(xUserService.getXUserByUserName("noUser")).thenReturn(null);
+ Mockito.when(restErrorUtil.createGrantRevokeRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(InvocationTargetException.class, () -> m.invoke(serviceREST, "noUser"));
+ }
+
+ @Test
+ public void testDeleteService_InvokesStore() throws Exception {
+ RangerSecurityContext context = new RangerSecurityContext();
+ UserSessionBase session = new UserSessionBase();
+ XXPortalUser portalUser = new XXPortalUser();
+ portalUser.setId(Id);
+ session.setXXPortalUser(portalUser);
+ context.setUserSession(session);
+ RangerContextHolder.setSecurityContext(context);
+ XXService xService = xService();
+ xService.setAddedByUserId(Id);
+ xService.setType(999L);
+ XXServiceDao xxServiceDao = Mockito.mock(XXServiceDao.class);
+ Mockito.when(daoManager.getXXService()).thenReturn(xxServiceDao);
+ Mockito.when(xxServiceDao.getById(Id)).thenReturn(xService);
+ XXServiceDef xServiceDef = serviceDef();
+ XXServiceDefDao xxServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xxServiceDefDao);
+ Mockito.when(xxServiceDefDao.getById(999L)).thenReturn(xServiceDef);
+ Mockito.when(validatorFactory.getServiceValidator(svcStore)).thenReturn(serviceValidator);
+ Mockito.doNothing().when(serviceValidator).validate(Mockito.eq(Id), Mockito.eq(Action.DELETE));
+ Mockito.doNothing().when(tagStore).deleteAllTagObjectsForService(Mockito.anyString());
+ Mockito.doNothing().when(svcStore).deleteService(Id);
+ Assertions.assertDoesNotThrow(() -> serviceREST.deleteService(Id));
+ Mockito.verify(svcStore).deleteService(Id);
+ }
+
+ @Test
+ public void testCreatePolicesBasedOnPolicyMap_CreatesOne() throws Exception {
+ ServiceREST spy = Mockito.spy(serviceREST);
+ Method m = ServiceREST.class.getDeclaredMethod("createPolicesBasedOnPolicyMap", HttpServletRequest.class, Map.class, List.class, boolean.class, int.class);
+ m.setAccessible(true);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Mockito.when(request.getParameter("mergeIfExists")).thenReturn("true");
+ RangerPolicy policy = rangerPolicy();
+ policy.setService(rangerService().getName());
+ Map<String, RangerPolicy> map = new HashMap<>();
+ map.put("k", policy);
+ List<String> serviceNames = Collections.singletonList(rangerService().getName());
+
+ Mockito.doReturn(policy).when(spy).createPolicy(Mockito.eq(policy), Mockito.eq(request));
+ int ret = (int) m.invoke(spy, request, map, serviceNames, false, 0);
+ Assertions.assertEquals(1, ret);
+ }
+
+ @Test
+ public void testEnsureAdminAccess_ZoneAdminAllowed() {
+ ServiceREST spy = Mockito.spy(serviceREST);
+ RangerPolicy policy = rangerPolicy();
+ policy.setZoneName("zone1");
+ Mockito.when(bizUtil.isAdmin()).thenReturn(false);
+ Mockito.when(bizUtil.isKeyAdmin()).thenReturn(false);
+ Mockito.when(bizUtil.getCurrentUserLoginId()).thenReturn("user");
+ Mockito.when(svcStore.isServiceAdminUser(Mockito.anyString(), Mockito.anyString())).thenReturn(false);
+ Mockito.when(serviceMgr.isZoneAdmin("zone1")).thenReturn(true);
+ Assertions.assertDoesNotThrow(() -> spy.ensureAdminAccess(policy));
+ }
+
+ @Test
+ public void testGetAllFilteredPolicyList_DoesNotThrow() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("getAllFilteredPolicyList", SearchFilter.class, HttpServletRequest.class, List.class);
+ m.setAccessible(true);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Assertions.assertDoesNotThrow(() -> {
+ try {
+ m.invoke(serviceREST, new SearchFilter(), request, new ArrayList<>());
+ } catch (InvocationTargetException ite) {
+ throw new RuntimeException(ite.getCause());
+ }
+ });
+ }
+
+ @Test
+ public void testValidateGroups_Grantees_Roles_Throws() throws Exception {
+ Method mg = ServiceREST.class.getDeclaredMethod("validateGroups", Set.class);
+ Method mu = ServiceREST.class.getDeclaredMethod("validateGrantees", Set.class);
+ Method mr = ServiceREST.class.getDeclaredMethod("validateRoles", Set.class);
+ mg.setAccessible(true);
+ mu.setAccessible(true);
+ mr.setAccessible(true);
+ Mockito.when(userMgr.getGroupByGroupName("g1")).thenReturn(null);
+ Mockito.when(xUserService.getXUserByUserName("u1")).thenReturn(null);
+ XXRoleDao roleDao = Mockito.mock(XXRoleDao.class);
+ Mockito.when(daoManager.getXXRole()).thenReturn(roleDao);
+ Mockito.when(roleDao.findByRoleName("r1")).thenReturn(null);
+ Mockito.when(restErrorUtil.createGrantRevokeRESTException(Mockito.anyString())).thenReturn(new WebApplicationException());
+ Assertions.assertThrows(InvocationTargetException.class, () -> mg.invoke(serviceREST, Collections.singleton("g1")));
+ Assertions.assertThrows(InvocationTargetException.class, () -> mu.invoke(serviceREST, Collections.singleton("u1")));
+ Assertions.assertThrows(InvocationTargetException.class, () -> mr.invoke(serviceREST, Collections.singleton("r1")));
+ }
+
+ @Test
+ public void testGetRangerAdminZoneName_ReturnsGiven() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("getRangerAdminZoneName", String.class, GrantRevokeRequest.class);
+ m.setAccessible(true);
+ GrantRevokeRequest req = new GrantRevokeRequest();
+ req.setZoneName("zoneX");
+ String ret = (String) m.invoke(serviceREST, "svc", req);
+ Assertions.assertEquals("zoneX", ret);
+ }
+
+ @Test
+ public void testResetPolicyCacheAll_AdminTrue() {
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
+ Mockito.when(svcStore.resetPolicyCache(null)).thenReturn(true);
+ boolean ret = serviceREST.resetPolicyCacheAll();
+ Assertions.assertTrue(ret);
+ Mockito.verify(svcStore).resetPolicyCache(null);
+ }
+
+ @Test
+ public void testGetOptions_NullRequestReturnsNull() throws Exception {
+ Method m = ServiceREST.class.getDeclaredMethod("getOptions", HttpServletRequest.class);
+ m.setAccessible(true);
+ @SuppressWarnings("unchecked")
+ Map<String, Object> ret = (Map<String, Object>) m.invoke(serviceREST, new Object[] {null});
+ Assertions.assertNull(ret);
+ }
+
+ @Test
+ public void testGetOptions_ForceRenameTrue() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Mockito.when(request.getParameter(ServiceStore.OPTION_FORCE_RENAME)).thenReturn("true");
+ Method m = ServiceREST.class.getDeclaredMethod("getOptions", HttpServletRequest.class);
+ m.setAccessible(true);
+ @SuppressWarnings("unchecked")
+ Map<String, Object> ret = (Map<String, Object>) m.invoke(serviceREST, request);
+ Assertions.assertNotNull(ret);
+ Assertions.assertEquals(Boolean.TRUE, ret.get(ServiceStore.OPTION_FORCE_RENAME));
+ }
+
+ @Test
+ public void testDeletePoliciesForResource_DeletesNonExported_2() throws Exception {
+ ServiceREST spy = Mockito.spy(serviceREST);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+ Mockito.when(searchUtil.getSearchFilter(Mockito.eq(request), Mockito.any())).thenReturn(filter);
+ // prepare destination policies: one keep, one delete
+ RangerPolicy keep = new RangerPolicy();
+ keep.setId(1L);
+ keep.setName("keep");
+ keep.setResources(new HashMap<>());
+ RangerPolicy del = new RangerPolicy();
+ del.setId(2L);
+ del.setName("del");
+ del.setResources(new HashMap<>());
+ RangerPolicyList list = new RangerPolicyList();
+ list.setPolicies(Arrays.asList(keep, del));
+ // private method getServicePolicies; use reflection rather than stubbing the private directly
+ Mockito.doReturn(new RangerService()).when(spy).getServiceByName("destSvc");
+ Method getSvcPolicies = ServiceREST.class.getDeclaredMethod("getServicePolicies", String.class, SearchFilter.class);
+ getSvcPolicies.setAccessible(true);
+ // let getServicePolicies call through; ensure admin path to bypass applyAdminAccessFilter complexities
+ Mockito.when(svcStore.getServicePolicies(Mockito.eq("destSvc"), Mockito.any(SearchFilter.class))).thenReturn(Arrays.asList(keep, del));
+ Mockito.when(bizUtil.isAdmin()).thenReturn(true);
+ // export list contains keep only
+ List<RangerPolicy> exportPolicies = Arrays.asList(keep);
+ // invoke private via reflection and only assert no exception
+ Method m = ServiceREST.class.getDeclaredMethod("deletePoliciesForResource", List.class, List.class, HttpServletRequest.class, List.class, String.class);
+ m.setAccessible(true);
+ Assertions.assertDoesNotThrow(() -> {
+ try {
+ m.invoke(spy, Arrays.asList("srcSvc"), Arrays.asList("destSvc"), request, exportPolicies, "");
+ } catch (InvocationTargetException ite) {
+ throw new RuntimeException(ite.getCause());
+ }
+ });
+ }
+
+ @Test
+ public void testGetAllFilteredPolicyList_FiltersAndResourceMatch() throws Exception {
+ ServiceREST spy = Mockito.spy(serviceREST);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
... 6373 lines suppressed ...