Fix test reliability issues:

- Remove global config loading from test files
- Use base_url fixture consistently
- Add proper error handling for test data loading
- Add better error messages and context
- Add request timeouts
- Add detailed error reporting for schema validation
- Add comprehensive test data validation
- Add better Allure attachments for debugging

These changes improve test reliability and debugging by:
1. Preventing configuration loading race conditions
2. Adding proper error context for failures
3. Improving error handling and reporting
4. Making test data loading more robust

Author: SaahilParmar

tests/test_api_validation.py

@@ -8,12 +8,9 @@
 import pytest
 import requests
 import allure
+import json
 from jsonschema import validate
-from utils.api_utils import load_config, load_schema, get_headers
-
-# Load base configuration from config.yaml
-config = load_config()
-BASE_URL = config["environments"][config["env"]]["base_url"]
+from utils.api_utils import load_schema, get_headers
 
 
 @pytest.mark.api_validation
@@ -22,37 +19,51 @@
 @allure.feature("Response Headers")
 @allure.title("Validate Standard Headers")
 @allure.severity(allure.severity_level.TRIVIAL)
-def test_headers_validation():
+def test_headers_validation(base_url):
     """
     Test that standard headers are present and correct in the API response.
     Validates content type, encoding, and other standard HTTP headers.
     """
     with allure.step("Send GET request to users endpoint"):
-        url = f"{BASE_URL}/users?page=1"
-        response = requests.get(url, headers=get_headers())
+        try:
+            url = f"{base_url}/users?page=1"
+            response = requests.get(url, headers=get_headers(), timeout=10)
+        except requests.exceptions.RequestException as e:
+            allure.attach(str(e), "Request Error", allure.attachment_type.TEXT)
+            raise
 
     with allure.step("Verify response status is 200"):
-        assert response.status_code == 200
+        assert response.status_code == 200, (
+            f"Expected status 200, got {response.status_code}. "
+            f"Response: {response.text}"
+        )
 
     with allure.step("Validate Content-Type header"):
-        assert response.headers["Content-Type"].startswith("application/json")
+        content_type = response.headers.get("Content-Type", "")
+        assert content_type.startswith("application/json"), (
+            f"Expected application/json Content-Type, got: {content_type}"
+        )
 
     with allure.step("Validate response headers are present"):
+        headers = dict(response.headers)
+        allure.attach(
+            json.dumps(headers, indent=2),
+            "Response Headers",
+            allure.attachment_type.JSON
+        )
+
         # Check for Content-Type (always present)
-        assert "Content-Type" in response.headers
+        assert "Content-Type" in headers, "Missing Content-Type header"
 
         # Check for either Content-Length or Transfer-Encoding (both are valid)
-        has_content_length = "Content-Length" in response.headers
-        has_transfer_encoding = "Transfer-Encoding" in response.headers
-        assert has_content_length or has_transfer_encoding, \
-            "Either Content-Length or Transfer-Encoding should be present"
+        has_content_length = "Content-Length" in headers
+        has_transfer_encoding = "Transfer-Encoding" in headers
+        assert has_content_length or has_transfer_encoding, (
+            "Missing both Content-Length and Transfer-Encoding headers"
+        )
 
         # Validate Date header is present
-        assert "Date" in response.headers
-
-    with allure.step("Attach headers to report"):
-        headers_info = dict(response.headers)
-        allure.attach(str(headers_info), "Response Headers", allure.attachment_type.TEXT)
+        assert "Date" in headers, "Missing Date header"
 
 
 @pytest.mark.api_validation
@@ -61,13 +72,13 @@ def test_headers_validation():
 @allure.feature("Schema Validation")
 @allure.title("Validate User List Schema Compliance")
 @allure.severity(allure.severity_level.CRITICAL)
-def test_user_list_schema_validation():
+def test_user_list_schema_validation(base_url):
     """
     Comprehensive schema validation for user list endpoint.
     Ensures all required fields and data types are correct.
     """
     with allure.step("Send GET request to user list endpoint"):
-        url = f"{BASE_URL}/users?page=1"
+        url = f"{base_url}/users?page=1"
         response = requests.get(url, headers=get_headers())
 
     with allure.step("Verify response status is 200"):
@@ -107,13 +118,13 @@ def test_user_list_schema_validation():
 @allure.feature("Schema Validation")
 @allure.title("Validate Single User Schema Compliance")
 @allure.severity(allure.severity_level.CRITICAL)
-def test_single_user_schema_validation():
+def test_single_user_schema_validation(base_url):
     """
     Comprehensive schema validation for single user endpoint.
     Ensures response structure matches expected contract.
     """
     with allure.step("Send GET request to single user endpoint"):
-        url = f"{BASE_URL}/users/2"
+        url = f"{base_url}/users/2"
         response = requests.get(url, headers=get_headers())
 
     with allure.step("Verify response status is 200"):
@@ -150,13 +161,13 @@ def test_single_user_schema_validation():
 @allure.title("Validate Response Time Performance")
 @allure.severity(allure.severity_level.NORMAL)
 @pytest.mark.parametrize("endpoint", ["/users?page=1", "/users/1"])
-def test_response_time_validation(endpoint):
+def test_response_time_validation(endpoint, base_url):
     """
     Test that API responses are returned within acceptable time limits.
     Validates performance requirements.
     """
     with allure.step(f"Send GET request to {endpoint}"):
-        url = f"{BASE_URL}{endpoint}"
+        url = f"{base_url}{endpoint}"
         response = requests.get(url, headers=get_headers())
 
     with allure.step("Verify response status is 200"):

tests/test_error_scenarios.py

@@ -8,11 +8,8 @@
 import pytest
 import requests
 import allure
-from utils.api_utils import load_config, get_headers
-
-# Load base configuration from config.yaml
-config = load_config()
-BASE_URL = config["environments"][config["env"]]["base_url"]
+import json
+from utils.api_utils import get_headers
 
 
 @pytest.mark.error_scenarios
@@ -21,25 +18,37 @@
 @allure.feature("User Retrieval Errors")
 @allure.title("GET Non-Existent User")
 @allure.severity(allure.severity_level.MINOR)
-def test_get_user_not_found():
+def test_get_user_not_found(base_url):
     """
     Test retrieving a non-existent user.
     Expects a 404 Not Found response.
     """
     with allure.step("Send GET request for non-existent user"):
-        url = f"{BASE_URL}/users/9999"
-        response = requests.get(url, headers=get_headers())
+        url = f"{base_url}/users/9999"
+        response = requests.get(url, headers=get_headers(), timeout=10)
 
     with allure.step("Verify response status is 404"):
-        assert response.status_code == 404
+        assert response.status_code == 404, (
+            f"Expected status 404, got {response.status_code}. "
+            f"Response: {response.text}"
+        )
 
     with allure.step("Verify response body is empty or contains error info"):
-        # ReqRes API returns empty object for 404
-        data = response.json()
-        assert data == {}
+        try:
+            data = response.json()
+            assert data == {}, f"Expected empty object, got: {json.dumps(data, indent=2)}"
+        except json.JSONDecodeError as e:
+            allure.attach(response.text, "Invalid JSON Response", allure.attachment_type.TEXT)
+            allure.attach(str(e), "JSON Parse Error", allure.attachment_type.TEXT)
+            raise
 
     with allure.step("Attach response details to report"):
         allure.attach(response.text, "404 Response Body", allure.attachment_type.JSON)
+        allure.attach(
+            json.dumps(get_headers(), indent=2),
+            "Request Headers",
+            allure.attachment_type.JSON
+        )
 
 
 @pytest.mark.error_scenarios
@@ -49,13 +58,13 @@ def test_get_user_not_found():
 @allure.title("GET User with Invalid ID Format")
 @allure.severity(allure.severity_level.MINOR)
 @pytest.mark.parametrize("invalid_id", ["abc", "!@#", "0", "-1"])
-def test_get_user_invalid_id(invalid_id):
+def test_get_user_invalid_id(invalid_id, base_url):
     """
     Test retrieving a user with invalid ID formats.
     Validates error handling for malformed requests.
     """
     with allure.step(f"Send GET request with invalid ID: {invalid_id}"):
-        url = f"{BASE_URL}/users/{invalid_id}"
+        url = f"{base_url}/users/{invalid_id}"
         response = requests.get(url, headers=get_headers())
 
     with allure.step("Verify response indicates error or not found"):
@@ -72,13 +81,13 @@ def test_get_user_invalid_id(invalid_id):
 @allure.feature("User Creation Errors")
 @allure.title("POST User with Empty Payload")
 @allure.severity(allure.severity_level.NORMAL)
-def test_create_user_empty_payload():
+def test_create_user_empty_payload(base_url):
     """
     Test creating a user with empty payload.
     Validates API behavior with missing data.
     """
     with allure.step("Send POST request with empty payload"):
-        url = f"{BASE_URL}/users"
+        url = f"{base_url}/users"
         response = requests.post(url, json={}, headers=get_headers())
 
     with allure.step("Verify response (API may accept empty payload)"):
@@ -101,13 +110,13 @@ def test_create_user_empty_payload():
 @allure.feature("User Creation Errors")
 @allure.title("POST User with Invalid JSON")
 @allure.severity(allure.severity_level.NORMAL)
-def test_create_user_invalid_json():
+def test_create_user_invalid_json(base_url):
     """
     Test creating a user with malformed JSON.
     Validates API error handling for invalid request format.
     """
     with allure.step("Send POST request with invalid JSON"):
-        url = f"{BASE_URL}/users"
+        url = f"{base_url}/users"
         headers = get_headers()
         # Send malformed JSON as string
         response = requests.post(url, data='{"name": "test", "job":}', headers=headers)
@@ -126,13 +135,13 @@ def test_create_user_invalid_json():
 @allure.feature("Invalid Endpoints")
 @allure.title("GET Invalid Endpoint")
 @allure.severity(allure.severity_level.MINOR)
-def test_invalid_endpoint():
+def test_invalid_endpoint(base_url):
     """
     Test accessing an invalid/non-existent endpoint.
     ReqRes API may handle invalid endpoints differently than expected.
     """
     with allure.step("Send GET request to invalid endpoint"):
-        url = f"{BASE_URL}/invalid-endpoint"
+        url = f"{base_url}/invalid-endpoint"
         response = requests.get(url, headers=get_headers())
 
     with allure.step("Document API behavior for invalid endpoints"):
@@ -160,14 +169,14 @@ def test_invalid_endpoint():
 @allure.feature("Invalid Endpoints")
 @allure.title("GET Non-existent User ID")
 @allure.severity(allure.severity_level.MINOR)
-def test_malformed_url():
+def test_malformed_url(base_url):
     """
     Test accessing a user with an ID that definitely doesn't exist.
     ReqRes API returns 404 for non-existent user IDs.
     """
     with allure.step("Send GET request to non-existent user ID"):
         # Use a very high user ID that definitely doesn't exist
-        url = f"{BASE_URL}/users/999999"
+        url = f"{base_url}/users/999999"
         response = requests.get(url, headers=get_headers())
 
     with allure.step("Verify response indicates not found"):