| # 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 random | |
| import string | |
| import uuid | |
| import pytest | |
| import requests | |
| import time | |
| import os | |
| # Module-level constants — always available globally, even with pytest -n auto | |
| CREDENTIALS = ("admin", "rangerR0cks!") | |
| DEFAULT_HEADERS = { | |
| "Accept": "application/json", | |
| "Content-Type": "application/json" | |
| } | |
| KEYADMIN_CREDENTIALS = ("keyadmin", "rangerR0cks!") | |
| @pytest.fixture(scope="session") | |
| def credentials(): | |
| return CREDENTIALS | |
| @pytest.fixture(scope="session") | |
| def default_headers(): | |
| return DEFAULT_HEADERS | |
| @pytest.fixture(scope="session") | |
| def keyadmin_credentials(): | |
| return KEYADMIN_CREDENTIALS | |
| def create_user_with_retry(url, **kwargs): | |
| import time | |
| for attempt in range(5): | |
| response = requests.post(url, **kwargs) | |
| if response.status_code == 200: | |
| return response | |
| time.sleep(1 + attempt) | |
| raise AssertionError(f"User creation failed: {response.text}") | |
| @pytest.fixture(scope="function") | |
| def ranger_session(ranger_config): | |
| session = requests.Session() | |
| session.auth = ranger_config["auth"] | |
| session.headers.update(ranger_config["headers"]) | |
| return session | |
| @pytest.fixture(scope="session") | |
| def ranger_config(credentials, default_headers): | |
| return { | |
| "base_url": "http://localhost:6080/service", | |
| "auth": credentials, | |
| "headers": default_headers | |
| } | |
| @pytest.fixture(scope="session") | |
| def ranger_key_admin_config(keyadmin_credentials, default_headers): | |
| return { | |
| "id" : 3, | |
| "base_url": "http://localhost:6080/service", | |
| "auth": keyadmin_credentials, | |
| "headers": default_headers | |
| } | |
| @pytest.fixture(scope="class") | |
| def temp_secure_user(ranger_config): | |
| created_user_ids = [] | |
| def _create_user(role_list = None): | |
| worker = os.getenv("PYTEST_XDIST_WORKER", "gw0") | |
| username = f"pytest_{worker}_{uuid.uuid4().hex[:8]}" | |
| role_map = { | |
| "user": "ROLE_USER", | |
| "admin": "ROLE_SYS_ADMIN", | |
| "auditor": "ROLE_ADMIN_AUDITOR" | |
| } | |
| if role_list: | |
| unique_roles = {role_map.get(role.lower(), "ROLE_USER") for role in role_list} | |
| else: | |
| unique_roles = {"ROLE_USER"} | |
| final_role_list = list(unique_roles) | |
| payload = { | |
| "name": username, | |
| "firstName": "Fixture", | |
| "lastName": "User", | |
| "emailAddress": f"{username}@test.com", | |
| "password": "Test@123", | |
| "status": 1, | |
| "isVisible": 1, | |
| "userSource":1, # to ensure it's created as an external user | |
| "userRoleList": final_role_list, | |
| "syncSource":"EXTERNAL_PYTEST", | |
| "otherAttributes":"{\"sync_source\":\"EXTERNAL_PYTEST\"}", | |
| "groupIdList": [], | |
| "groupNameList": [] | |
| } | |
| response = create_user_with_retry( | |
| f"{ranger_config['base_url']}/xusers/secure/users", | |
| json=payload, | |
| auth=ranger_config["auth"], | |
| headers=ranger_config["headers"] | |
| ) | |
| #time.sleep(0.5) | |
| assert response.status_code == 200, f"User creation failed: {response.text}" | |
| created_user = response.json() | |
| created_user_ids.append(created_user["id"]) | |
| print(f"\n[Fixture] Created user ID: {created_user['id']}, Roles: {final_role_list}") | |
| return created_user, created_user["id"] | |
| yield _create_user | |
| for user_id in created_user_ids: | |
| print(f"[Fixture] Cleaning up user ID: {user_id}") | |
| response = requests.delete( | |
| f"{ranger_config['base_url']}/xusers/users/{user_id}", | |
| params={"forceDelete": "true"}, | |
| auth=ranger_config["auth"], | |
| headers={**ranger_config["headers"], "X-Requested-By": "ranger"} | |
| ) | |
| print("DELETE RESPONSE:", response.status_code, response.text) | |
| if response.status_code in [200, 204]: | |
| print(f"[Fixture] Deleted user ID: {user_id}") | |
| elif response.status_code in [400, 404]: | |
| print(f"[Fixture] User ID {user_id} already deleted") | |
| else: | |
| pytest.fail( | |
| f"Unexpected error deleting user ID {user_id}: {response.text}" | |
| ) | |
| @pytest.fixture(scope="class") | |
| def temp_keyadmin_user(ranger_config, role = "keyadmin"): | |
| created_user_ids = [] | |
| def _create_keyadmin(): | |
| #username = f"pytest_keyadmin_{uuid.uuid4().hex[:8]}" | |
| worker = os.getenv("PYTEST_XDIST_WORKER", "gw0") | |
| username = f"pytest_keyadmin_{worker}_{uuid.uuid4().hex[:8]}" | |
| payload = { | |
| "name": username, | |
| "firstName": "Fixture", | |
| "lastName": "KeyAdmin", | |
| "emailAddress": f"{username}@test.com", | |
| "password": "Test@123", | |
| "status": 1, | |
| "isVisible": 1, | |
| "userRoleList": ["ROLE_USER"], | |
| "groupIdList": [], | |
| "groupNameList": [] | |
| } | |
| response = create_user_with_retry( | |
| f"{ranger_config['base_url']}/xusers/secure/users", | |
| json=payload, | |
| auth=ranger_config["auth"], | |
| headers=ranger_config["headers"] | |
| ) | |
| assert response.status_code == 200 | |
| user = response.json() | |
| user_id = user["id"] | |
| print(f"\n[Fixture] Created keyadmin base: {username} ({user_id})") | |
| # promote to keyadmin | |
| #requests.put( | |
| response = requests.put( | |
| f"{ranger_config['base_url']}/xusers/secure/users/roles/{user_id}", | |
| json={"vXStrings": [{"value": "ROLE_KEY_ADMIN"}]}, | |
| auth=("keyadmin", "rangerR0cks!"), | |
| headers={**ranger_config["headers"], "X-Requested-By": "ranger"} | |
| ) | |
| #time.sleep(0.5) | |
| created_user_ids.append(user_id) | |
| return user, user_id | |
| yield _create_keyadmin | |
| # cleanup | |
| for user_id in created_user_ids: | |
| print(f"[Fixture] Cleaning keyadmin {user_id}") | |
| requests.put( | |
| f"{ranger_config['base_url']}/xusers/secure/users/roles/{user_id}", | |
| json={"vXStrings": [{"value": "ROLE_USER"}]}, | |
| auth=("keyadmin", "rangerR0cks!"), | |
| headers={**ranger_config["headers"], "X-Requested-By": "ranger"} | |
| ) | |
| requests.delete( | |
| f"{ranger_config['base_url']}/xusers/secure/users/id/{user_id}", | |
| params={"forceDelete": "true"}, | |
| auth=ranger_config["auth"], | |
| headers={**ranger_config["headers"], "X-Requested-By": "ranger"} | |
| ) | |
| @pytest.fixture(scope="class") | |
| def temp_group(ranger_config): | |
| created_group_ids = [] | |
| def _create_group(): | |
| group_name = f"pytest_group_{uuid.uuid4().hex[:8]}" | |
| payload = { | |
| "name": group_name, | |
| "groupSource" : 1, # to ensure it's created as an external group | |
| "groupType" : 1, | |
| "syncSource":"EXTERNAL_PYTEST", | |
| "otherAttributes":"{\"sync_source\":\"EXTERNAL_PYTEST\"}", | |
| } | |
| response = requests.post( | |
| f"{ranger_config['base_url']}/xusers/groups", | |
| json=payload, | |
| auth=ranger_config["auth"], | |
| headers=ranger_config["headers"] | |
| ) | |
| assert response.status_code in (200, 201), response.text | |
| data = response.json() | |
| group_id = data["id"] | |
| created_group_ids.append(group_id) | |
| print(f"[Fixture] Created group {group_name} ({group_id})") | |
| return data, group_id | |
| yield _create_group | |
| # -------- CLEANUP ---------- | |
| for gid in created_group_ids: | |
| print(f"[Fixture] Cleaning group {gid}") | |
| requests.delete( | |
| f"{ranger_config['base_url']}/xusers/groups/{gid}", | |
| auth=ranger_config["auth"], | |
| params={"forceDelete": "true"}, | |
| headers={ | |
| **ranger_config["headers"], | |
| "X-Requested-By": "ranger" | |
| } | |
| ) | |
| @pytest.fixture(scope="class") | |
| def temp_role(ranger_config): | |
| created_role_ids = [] | |
| def _create_role(user_list = [], group_list = [], role_list = []): | |
| role_name = f"pytest_role_{uuid.uuid4().hex[:8]}" | |
| if user_list: | |
| for user in user_list: | |
| assert "name" in user, "User dict must contain 'name' key" | |
| assert "isAdmin" in user, "User dict must contain 'isAdmin' key" | |
| if group_list: | |
| for group in group_list: | |
| assert "name" in group, "Group dict must contain 'name' key" | |
| assert "isAdmin" in group, "Group dict must contain 'isAdmin' key" | |
| if role_list: | |
| for role in role_list: | |
| assert "name" in role, "Role dict must contain 'name' key" | |
| assert "isAdmin" in role, "Role dict must contain 'isAdmin' key" | |
| payload = { | |
| "name": role_name, | |
| "description": "Role created by pytest fixture", | |
| "users": user_list, | |
| "groups": group_list, | |
| "roles": role_list | |
| } | |
| response = requests.post( | |
| f"{ranger_config['base_url']}/roles/roles", | |
| json=payload, | |
| auth=ranger_config["auth"], | |
| headers=ranger_config["headers"] | |
| ) | |
| assert response.status_code in (200, 201), response.text | |
| data = response.json() | |
| role_id = data["id"] | |
| created_role_ids.append(role_id) | |
| print(f"[Fixture] Created role {role_name} ({role_id})") | |
| return data, role_id | |
| yield _create_role | |
| # # -------- CLEANUP ---------- | |
| for rid in created_role_ids: | |
| print(f"[Fixture] Cleaning role {rid}") | |
| requests.delete( | |
| f"{ranger_config['base_url']}/roles/roles/{rid}", | |
| auth=ranger_config["auth"], | |
| params={"forceDelete": "true"}, | |
| headers={ | |
| **ranger_config["headers"], | |
| "X-Requested-By": "ranger" | |
| } | |
| ) |