blob: 8ad489979d59f25f59dcddf5724d1c33c1ae2f43 [file]
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import pytest
import os
import requests
import json
from requests.auth import HTTPBasicAuth
from Utility.main import base_url, admin_auth, headers, get_request_data, str_variable_dict ,keyadmin_auth
# Use absolute path relative to this file
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
RESOURCE_MAPPING_DIRECTORY = os.path.join(BASE_DIR, "Utility", "variable_jsons", "resource_mappings")
def test_create_service_resource(log):
"""Test to create and delete service resource mappings"""
log.info("Starting test: Creating service and resource IDs")
# Creating resource ids for different resources in different types of services
service_resource_responses = {}
request_url = base_url + "/tags/resources"
mapping_array = ["hbase_mapping", "hdfs_mapping", "hive_mapping", "kafka_mapping"]
# Create resources
for mapping in mapping_array:
# Verify file exists before making request
file_path = os.path.join(RESOURCE_MAPPING_DIRECTORY, f"{mapping}.json")
if not os.path.exists(file_path):
log.error(f"File not found: {file_path}")
pytest.fail(f"Mapping file not found: {file_path}")
request_data = get_request_data(f"{mapping}.json", str_variable_dict, RESOURCE_MAPPING_DIRECTORY)
# First request - create resource
response1 = requests.post(request_url, verify=False, auth=admin_auth, headers=headers,
data=json.dumps(request_data))
assert response1.status_code == 200, f"Failed to create resource {mapping}: {response1.text}"
response1_data = response1.json()
service_resource_responses[mapping] = response1_data
log.info(
f"Successfully created resource mapping for {mapping} with version {response1_data.get('version')}")
# Second request - update should increment version
response2 = requests.post(request_url, verify=False, auth=admin_auth, headers=headers,
data=json.dumps(request_data))
assert response2.status_code == 200, f"Failed to update resource {mapping}: {response2.text}"
response2_data = response2.json()
assert response2_data["version"] > response1_data["version"], \
f"Version should increment: {response2_data['version']} should be > {response1_data['version']}"
log.info(f"Version incremented from {response1_data['version']} to {response2_data['version']}")
service_resource_responses[mapping] = response2_data
# Third request - with updateIfExists=false should fail
response3 = requests.post(request_url + "?updateIfExists=false", verify=False, auth=admin_auth,
headers=headers, data=json.dumps(request_data))
assert response3.status_code == 400, \
f"Resource {mapping} should not be created when updateIfExists is false: {response3.text}"
log.info(f"Correctly rejected duplicate creation for {mapping} with updateIfExists=false")
# Verify all resources were created
assert len(service_resource_responses) == len(mapping_array), "Not all resources were created successfully"
# Cleanup: Delete all created resources
log.info("Starting cleanup: Deleting created resources")
for mapping, response_data in service_resource_responses.items():
resource_id = response_data.get("id")
if resource_id:
delete_url = f"{base_url}/tags/resource/{resource_id}"
delete_response = requests.delete(delete_url, verify=False, auth=admin_auth, headers=headers)
if delete_response.status_code in [200, 204, 201]:
log.info(f"Successfully deleted resource {mapping} (ID: {resource_id})")
else:
log.error(f"Failed to delete resource {mapping} (ID: {resource_id}): {delete_response.text}")
def test_get_service_resource_using_id(log, create_service_resource_ids):
"""Test to get service resource mapping using ID"""
for mapping, response_data in create_service_resource_ids.items():
resource_id = response_data.get("id")
if not resource_id:
log.error(f"No resource ID found for {mapping}")
pytest.fail(f"No resource ID found for {mapping}")
get_url = f"{base_url}/tags/resource/{resource_id}"
get_response = requests.get(get_url, verify=False, auth=admin_auth, headers=headers)
assert get_response.status_code == 200, f"Failed to get resource {mapping} by ID: {get_response.text}"
get_response_data = get_response.json()
assert get_response_data["id"] == resource_id, f"Resource ID mismatch for {mapping}"
log.info(f"Successfully retrieved resource {mapping} by ID with version {get_response_data.get('version')}")
# @pytest.mark.skip(reason="Bug in Ranger code base , for unauthorized users status code should be 403 but it is throwing 404 for keyadmin ,user admin auditor role")
def test_get_service_resource_using_id_by_roles_other_than_admin(log, create_service_resource_ids):
"""Test to verify unauthorized users cannot get service resource mapping using ID"""
for mapping, response_data in create_service_resource_ids.items():
resource_id = response_data.get("id")
if not resource_id:
log.error(f"No resource ID found for {mapping}")
pytest.fail(f"No resource ID found for {mapping}")
get_url = f"{base_url}/tags/resource/{resource_id}"
# Test with keyadmin
get_response = requests.get(get_url, verify=False, auth=keyadmin_auth, headers=headers)
assert get_response.status_code in [403, 400,404], \
f"Unauthorized keyadmin allowed to get resource {mapping} by ID. Status: {get_response.status_code}, Response: {get_response.text}"
log.info(f"Keyadmin correctly denied access to {mapping} with status {get_response.status_code}")
# Test with user role
get_response = requests.get(get_url, verify=False, auth=HTTPBasicAuth(str_variable_dict["user2"], "Test@12345"), headers=headers)
assert get_response.status_code in [403, 400,404], \
f"Unauthorized user role allowed to get resource {mapping} by ID. Status: {get_response.status_code}, Response: {get_response.text}"
log.info(f"User role correctly denied access to {mapping} with status {get_response.status_code}")
# Test with admin auditor role
get_response = requests.get(get_url, verify=False, auth=HTTPBasicAuth(str_variable_dict["user4"], "Test@12345"), headers=headers)
assert get_response.status_code in [403, 400,404], \
f"Unauthorized admin auditor role allowed to get resource {mapping} by ID. Status: {get_response.status_code}, Response: {get_response.text}"
log.info(f"Admin auditor correctly denied access to {mapping} with status {get_response.status_code}")
#
# @pytest.mark.skip(reason="Bug in Ranger code base , for unauthorized users status code should be 403 but it is throwing 404 for keyadmin ,user admin auditor role")
def test_get_service_resource_using_guid_by_roles_other_than_admin(log, create_service_resource_ids):
"""Test to verify unauthorized users cannot get service resource mapping using GUID"""
for mapping, response_data in create_service_resource_ids.items():
resource_guid = response_data.get("guid")
if not resource_guid:
log.error(f"No resource GUID found for {mapping}")
pytest.fail(f"No resource GUID found for {mapping}")
get_url = f"{base_url}/tags/resource/guid/{resource_guid}"
# Test with keyadmin
get_response = requests.get(get_url, verify=False, auth=keyadmin_auth, headers=headers)
assert get_response.status_code in [403, 400,404], \
f"Unauthorized keyadmin allowed to get resource {mapping} by GUID. Status: {get_response.status_code}, Response: {get_response.text}"
log.info(f"Keyadmin correctly denied access to {mapping} with status {get_response.status_code}")
# Test with user role
get_response = requests.get(get_url, verify=False, auth=HTTPBasicAuth(str_variable_dict["user2"], "Test@12345"), headers=headers)
assert get_response.status_code in [403, 400,404], \
f"Unauthorized user role allowed to get resource {mapping} by GUID. Status: {get_response.status_code}, Response: {get_response.text}"
log.info(f"User role correctly denied access to {mapping} with status {get_response.status_code}")
# Test with admin auditor role
get_response = requests.get(get_url, verify=False, auth=HTTPBasicAuth(str_variable_dict["user4"], "Test@12345"), headers=headers)
assert get_response.status_code in [403, 400,404], \
f"Unauthorized admin auditor role allowed to get resource {mapping} by GUID. Status: {get_response.status_code}, Response: {get_response.text}"
log.info(f"Admin auditor correctly denied access to {mapping} with status {get_response.status_code}")
def test_get_service_resource_using_guid(log, create_service_resource_ids):
"""Test to get service resource mapping using GUID"""
for mapping, response_data in create_service_resource_ids.items():
resource_guid = response_data.get("guid")
if not resource_guid:
log.error(f"No resource GUID found for {mapping}")
pytest.fail(f"No resource GUID found for {mapping}")
get_url = f"{base_url}/tags/resource/guid/{resource_guid}"
get_response = requests.get(get_url, verify=False, auth=admin_auth, headers=headers)
assert get_response.status_code in [200,201,204], f"Failed to get resource {mapping} by GUID: {get_response.text}"
get_response_data = get_response.json()
assert get_response_data["guid"] == resource_guid, f"Resource GUID mismatch for {mapping}"
log.info(f"Successfully retrieved resource {mapping} by GUID with version {get_response_data.get('version')}")
def test_get_service_resource_by_resource_params(log, create_service_resource_ids):
"""Test to get service resource using resource query parameters"""
for mapping, response_data in create_service_resource_ids.items():
service_name = response_data.get("serviceName")
resource_elements = response_data.get("resourceElements", {})
actual_guid = response_data.get("guid")
if not service_name or not resource_elements:
log.error(f"Missing service name or resource elements for {mapping}")
pytest.fail(f"Incomplete resource data for {mapping}")
# Build query parameters from resource elements
get_url = f"{base_url}/tags/resource/service/{service_name}/resource"
params = {}
for resource_key, resource_value in resource_elements.items():
values = resource_value.get("values", [])
if values:
params[resource_key] = values[0] # Use first value
# Add boolean properties if present
if resource_value.get("isExcludes") is not None:
params[f"{resource_key}.isExcludes"] = str(resource_value.get("isExcludes")).lower()
if resource_value.get("isRecursive") is not None:
params[f"{resource_key}.isRecursive"] = str(resource_value.get("isRecursive")).lower()
get_response = requests.get(get_url, params=params, verify=False, auth=admin_auth, headers=headers)
log.info(f"Request URL: {get_response.url}")
log.info(f"Response Status: {get_response.status_code}")
log.info(f"Response Body: {get_response.text}")
assert get_response.status_code in [200,204] , f"Failed to get resource {mapping} by params. Expected 200, got {get_response.status_code}: {get_response.text}"
def test_put_resource_id(log):
request_url_post = base_url + "/tags/resources"
request_url_put= base_url + "/tags/resource"
mapping_array = ["hbase_mapping", "hdfs_mapping", "hive_mapping", "kafka_mapping"]
for mapping in mapping_array:
# Verify file exists before making request
file_path = os.path.join(RESOURCE_MAPPING_DIRECTORY, f"{mapping}.json")
if not os.path.exists(file_path):
log.error(f"File not found: {file_path}")
pytest.fail(f"Mapping file not found: {file_path}")
request_data1 = get_request_data(f"{mapping}.json", str_variable_dict, RESOURCE_MAPPING_DIRECTORY)
# First request - create resource
response1 = requests.post(request_url_post, verify=False, auth=admin_auth, headers=headers,
data=json.dumps(request_data1))
assert response1.status_code == 200, f"Failed to create resource {mapping}: {response1.text}"
if response1.status_code in [200,204]:
log.info(f"Successfully created resource mapping for {mapping} with version {response1.json().get('version')}")
else:
log.error(f"Failed to create resource mapping for {mapping}: {response1.text}")
request_data2= get_request_data(f"{mapping}.json", str_variable_dict, RESOURCE_MAPPING_DIRECTORY)
resource_id=response1.json().get("id")
final_request_url_put=request_url_put+"/"+str(resource_id)
response2 = requests.put(final_request_url_put, verify=False, auth=admin_auth, headers=headers,
data=json.dumps(request_data2))
assert response2.status_code == 200, f"Failed to update resource {mapping}: {response2.text}"
assert response2.json().get("version") > response1.json().get("version"), \
f"Version should increment: {response2.json().get('version')} should be > {response1.json().get('version')}"
# Compare only the resource values, not the boolean flags
for key in request_data2.get("resourceElements", {}).keys():
expected_values = request_data2["resourceElements"][key].get("values")
actual_values = response2.json()["resourceElements"][key].get("values")
assert actual_values == expected_values, \
f"Resource values mismatch for {key}: {actual_values} != {expected_values}"
log.info(f"Successfully verified resource elements for {mapping}")
assert response1.json().get("guid")==response2.json().get("guid"), f"GUID should not change on update {mapping}"
assert response1.json().get("resourceSignature")!=response2.json().get("resourceSignature"), f"resource signature should have changed on update "
# Deleting the created resource
delete_url = f"{base_url}/tags/resource/{resource_id}"
delete_response = requests.delete(delete_url, verify=False, auth=admin_auth, headers=headers)
if delete_response.status_code in [200, 204, 201]:
log.info(f"Successfully deleted resource {mapping} (ID: {resource_id})")
else:
log.error(f"Failed to delete resource {mapping} (ID: {resource_id}): {delete_response.text}")
def test_put_resource_id_guid(log):
request_url_post = base_url + "/tags/resources"
request_url_put= base_url + "/tags/resource/guid"
mapping_array = ["hbase_mapping", "hdfs_mapping", "hive_mapping", "kafka_mapping"]
for mapping in mapping_array:
# Verify file exists before making request
file_path = os.path.join(RESOURCE_MAPPING_DIRECTORY, f"{mapping}.json")
if not os.path.exists(file_path):
log.error(f"File not found: {file_path}")
pytest.fail(f"Mapping file not found: {file_path}")
request_data1 = get_request_data(f"{mapping}.json", str_variable_dict, RESOURCE_MAPPING_DIRECTORY)
# First request - create resource
response1 = requests.post(request_url_post, verify=False, auth=admin_auth, headers=headers,
data=json.dumps(request_data1))
assert response1.status_code == 200, f"Failed to create resource {mapping}: {response1.text}"
if response1.status_code in [200,204]:
log.info(f"Successfully created resource mapping for {mapping} with version {response1.json().get('version')}")
else:
log.error(f"Failed to create resource mapping for {mapping}: {response1.text}")
request_data2= get_request_data(f"{mapping}.json", str_variable_dict, RESOURCE_MAPPING_DIRECTORY)
resource_guid=response1.json().get("guid")
final_request_url_put=request_url_put+"/"+str(resource_guid)
response2 = requests.put(final_request_url_put, verify=False, auth=admin_auth, headers=headers,
data=json.dumps(request_data2))
assert response2.status_code == 200, f"Failed to update resource {mapping}: {response2.text}"
assert response2.json().get("version") > response1.json().get("version"), \
f"Version should increment: {response2.json().get('version')} should be > {response1.json().get('version')}"
# Compare only the resource values, not the boolean flags
for key in request_data2.get("resourceElements", {}).keys():
expected_values = request_data2["resourceElements"][key].get("values")
actual_values = response2.json()["resourceElements"][key].get("values")
assert actual_values == expected_values, \
f"Resource values mismatch for {key}: {actual_values} != {expected_values}"
log.info(f"Successfully verified resource elements for {mapping}")
assert response1.json().get("guid")==response2.json().get("guid"), f"GUID should not change on update {mapping}"
assert response1.json().get("resourceSignature")!=response2.json().get("resourceSignature"), f"resource signature should have changed on update "
# Deleting the created resource
delete_url = f"{base_url}/tags/resource/guid/{resource_guid}"
delete_response = requests.delete(delete_url, verify=False, auth=admin_auth, headers=headers)
if delete_response.status_code in [200, 204, 201]:
log.info(f"Successfully deleted resource {mapping} (ID: {resource_guid})")
else:
log.error(f"Failed to delete resource {mapping} (ID: {resource_guid}): {delete_response.text}")
def test_get_service_resource_using_resource_signature(log, create_service_resource_ids):
"""Test to get service resource mapping using ID"""
for mapping, response_data in create_service_resource_ids.items():
resource_signature = response_data.get("resourceSignature")
resource_id = response_data.get("id")
service_name = response_data.get("serviceName")
if not resource_signature:
log.error(f"No resource ID found for {mapping}")
pytest.fail(f"No resource ID found for {mapping}")
get_url = f"{base_url}/tags/resource/service/{service_name}/signature/{resource_signature}"
get_response = requests.get(get_url, verify=False, auth=admin_auth, headers=headers)
assert get_response.status_code in [200,201,204], f"Failed to get resource {mapping} by ID: {get_response.text}"
get_response_data = get_response.json()
assert get_response_data["resourceSignature"] == resource_signature, f"Resource ID mismatch for {mapping}"
assert get_response_data["id"] == resource_id, f"Resource ID mismatch for {mapping}"