Fix remaining workflow issues:

- Add comprehensive schema file validation
- Fix PYTHONPATH in virtual environment
- Create all required directories before tests
- Add better error handling in api_utils.py
- Improve error reporting in tests
- Add request timeouts and JSON validation
- Add detailed Allure attachments for failures

Author: SaahilParmar

.github/workflows/ci.yml

@@ -24,7 +24,6 @@ permissions:
 
 env:
   PYTHON_VERSION_DEFAULT: "3.11"
-  PYTHONPATH: ${{ github.workspace }}
 
 jobs:
   test:
@@ -51,21 +50,30 @@ jobs:
         restore-keys: |
           ${{ runner.os }}-pip-${{ matrix.python-version }}-
     
-    - name: Install dependencies
+    - name: Setup test environment
       run: |
         python -m pip install --upgrade pip
         python -m venv .venv
         source .venv/bin/activate
         pip install -r requirements.txt
         
-    - name: Verify test data and schemas
-      run: |
-        source .venv/bin/activate
+        # Ensure all required directories exist
         mkdir -p schemas
-        if [ ! -f "schemas/user_list_schema.json" ]; then
-          echo "Error: Missing schema files"
-          exit 1
-        fi
+        mkdir -p allure-results/smoke
+        mkdir -p allure-results/all
+        mkdir -p reports
+        
+        # Add workspace to PYTHONPATH inside venv
+        echo "${{ github.workspace }}" > .venv/lib/python${{ matrix.python-version }}/site-packages/workspace.pth
+        
+        # Verify required schema files
+        required_schemas=("user_list_schema.json" "single_user_schema.json" "create_user_schema.json")
+        for schema in "${required_schemas[@]}"; do
+          if [ ! -f "schemas/$schema" ]; then
+            echo "Error: Missing required schema file: $schema"
+            exit 1
+          fi
+        done
     
     - name: Lint with flake8
       run: |

tests/test_user_retrieval.py

@@ -8,7 +8,8 @@
 import pytest
 import requests
 import allure
-from jsonschema import validate
+import json
+from jsonschema import validate, ValidationError
 from utils.api_utils import load_schema, get_headers
 
 
@@ -24,23 +25,49 @@ def test_get_user_list(base_url):
     Validates response status and schema.
     """
     with allure.step("Send GET request to retrieve user list"):
-        url = f"{base_url}/users?page=2"
-        response = requests.get(url, headers=get_headers())
+        try:
+            url = f"{base_url}/users?page=2"
+            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, f"Expected status 200, got {response.status_code}"
+        assert response.status_code == 200, (
+            f"Expected status 200, got {response.status_code}. "
+            f"Response: {response.text}"
+        )
 
     with allure.step("Validate response against schema"):
-        data = response.json()
+        try:
+            data = response.json()
+        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
+
         try:
             schema = load_schema("user_list_schema.json")
             validate(instance=data, schema=schema)
-        except Exception as e:
+        except ValidationError as e:
+            allure.attach(
+                json.dumps(data, indent=2),
+                "Response Data",
+                allure.attachment_type.JSON
+            )
             allure.attach(str(e), "Schema Validation Error", allure.attachment_type.TEXT)
             raise
+        except Exception as e:
+            allure.attach(str(e), "Unexpected Error", allure.attachment_type.TEXT)
+            raise
 
     with allure.step("Attach response details to report"):
         allure.attach(response.text, "Response Body", allure.attachment_type.JSON)
+        allure.attach(
+            json.dumps(get_headers(), indent=2),
+            "Request Headers",
+            allure.attachment_type.JSON
+        )
 
 
 @pytest.mark.user_retrieval

utils/api_utils.py

@@ -25,9 +25,23 @@ def load_config():
 
     Returns:
         dict: Configuration dictionary.
+    
+    Raises:
+        FileNotFoundError: If config.yaml doesn't exist.
+        yaml.YAMLError: If config.yaml is invalid.
     """
-    with open("config/config.yaml", "r") as f:
-        return yaml.safe_load(f)
+    config_path = os.path.join("config", "config.yaml")
+    if not os.path.exists(config_path):
+        raise FileNotFoundError(f"Configuration file not found at {config_path}")
+
+    with open(config_path, "r") as f:
+        try:
+            config = yaml.safe_load(f)
+            if not config:
+                raise ValueError("Empty configuration file")
+            return config
+        except yaml.YAMLError as e:
+            raise yaml.YAMLError(f"Error parsing config.yaml: {str(e)}")
 
 
 def load_schema(schema_filename):
@@ -39,25 +53,39 @@ def load_schema(schema_filename):
 
     Returns:
         dict: Loaded JSON schema.
+    
+    Raises:
+        FileNotFoundError: If schema file doesn't exist.
+        json.JSONDecodeError: If schema is invalid JSON.
     """
     schema_path = os.path.join("schemas", schema_filename)
+    if not os.path.exists(schema_path):
+        raise FileNotFoundError(f"Schema file not found: {schema_filename}")
+
     with open(schema_path, "r") as f:
-        return json.load(f)
+        try:
+            schema = json.load(f)
+            if not schema:
+                raise ValueError(f"Empty schema file: {schema_filename}")
+            return schema
+        except json.JSONDecodeError as e:
+            raise json.JSONDecodeError(f"Invalid JSON in schema {schema_filename}: {str(e)}", e.doc, e.pos)
 
 
 def get_headers():
     """
     Get default headers defined in config.yaml.
-
+    
     Returns:
-        dict: HTTP headers.
+        dict: Headers from configuration.
+    
+    Raises:
+        KeyError: If default_headers section is missing from config.
     """
     config = load_config()
-    headers = config.get("default_headers", {})
-    allowed = {"Content-Type", "Accept", "x-api-key"}
-    filtered_headers = {k: v for k, v in headers.items() if k in allowed}
-    print("DEBUG: get_headers() returns:", filtered_headers)  # Debug print
-    return filtered_headers
+    if 'default_headers' not in config:
+        raise KeyError("default_headers section missing from config.yaml")
+    return config['default_headers']
 
 
 def retry_request(func):