Fix workflow failures: improve CI/CD pipeline, add concurrency control, fix test configuration

- Add concurrency control to prevent resource conflicts between matrix jobs
- Implement proper virtual environment usage in workflow
- Add fail-fast: false to continue other Python versions if one fails
- Improve dependency caching with Python version in cache key
- Add schema file validation step before tests run
- Fix conftest.py configuration management and validation
- Update test_user_retrieval.py to use fixtures properly
- Add better error handling and validation throughout
- Separate smoke test and full test results into different directories
- Enhance artifact upload to include all relevant test files
- Add environment properties generation for Allure reports

These changes address the root causes of workflow failures and should
significantly improve the success rate from 11/35 to near 100%.

Author: SaahilParmar

.github/workflows/ci.yml

@@ -10,6 +10,11 @@ name: API Test Automation CI/CD
     - cron: '0 6 * * *'
   workflow_dispatch:
 
+# Add concurrency control to prevent resource conflicts
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ matrix.python-version }}
+  cancel-in-progress: true
+
 permissions:
   contents: read
   pages: write
@@ -19,13 +24,16 @@ permissions:
 
 env:
   PYTHON_VERSION_DEFAULT: "3.11"
+  PYTHONPATH: ${{ github.workspace }}
 
 jobs:
   test:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+      # Add fail-fast false to continue with other versions if one fails
+      fail-fast: false
 
     steps:
     - uses: actions/checkout@v4
@@ -39,17 +47,29 @@ jobs:
       uses: actions/cache@v4
       with:
         path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        key: ${{ runner.os }}-pip-${{ matrix.python-version }}-${{ hashFiles('**/requirements.txt') }}
         restore-keys: |
-          ${{ runner.os }}-pip-
+          ${{ runner.os }}-pip-${{ matrix.python-version }}-
     
     - name: Install dependencies
       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
+        mkdir -p schemas
+        if [ ! -f "schemas/user_list_schema.json" ]; then
+          echo "Error: Missing schema files"
+          exit 1
+        fi
     
     - name: Lint with flake8
       run: |
+        source .venv/bin/activate
         pip install flake8
         # Stop the build if there are Python syntax errors or undefined names
         flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
@@ -58,12 +78,14 @@ jobs:
     
     - name: Run smoke tests
       run: |
-        python -m pytest tests/ -m smoke -v --tb=short
+        source .venv/bin/activate
+        python -m pytest tests/ -m smoke -v --tb=short --alluredir=allure-results/smoke
     
     - name: Run all tests with coverage
       run: |
+        source .venv/bin/activate
         pip install pytest-cov
-        python -m pytest tests/ -v --cov=utils --cov=tests --cov-report=xml --cov-report=html
+        python -m pytest tests/ -v --cov=utils --cov=tests --cov-report=xml --cov-report=html --alluredir=allure-results/all
     
     - name: Upload coverage to Codecov
       uses: codecov/codecov-action@v4
@@ -74,11 +96,6 @@ jobs:
         token: ${{ secrets.CODECOV_TOKEN }}
         fail_ci_if_error: false
 
-    - name: Generate Allure results
-      if: always()
-      run: |
-        python -m pytest tests/ --alluredir=allure-results --tb=short || true
-      
     - name: Install Allure CLI
       if: always()
       run: |
@@ -92,32 +109,21 @@ jobs:
     - name: Generate Allure HTML report
       if: always()
       run: |
-        allure generate allure-results --clean -o allure-report || echo "Allure report generation failed"
-    
-    - name: Upload Allure results
-      if: always()
-      uses: actions/upload-artifact@v4
-      with:
-        name: allure-results-${{ matrix.python-version }}
-        path: allure-results/
-        retention-days: 30
-        if-no-files-found: warn
-        
-    - name: Upload Allure HTML report
-      if: always()
-      uses: actions/upload-artifact@v4
-      with:
-        name: allure-report-${{ matrix.python-version }}
-        path: allure-report/
-        retention-days: 30
-        if-no-files-found: warn
+        source .venv/bin/activate
+        allure generate allure-results/all --clean -o allure-report/all || echo "Allure report generation failed"
+        allure generate allure-results/smoke --clean -o allure-report/smoke || echo "Smoke tests report generation failed"
     
     - name: Upload test reports
       if: always()
       uses: actions/upload-artifact@v4
       with:
         name: test-reports-${{ matrix.python-version }}
-        path: reports/
+        path: |
+          allure-results/
+          allure-report/
+          reports/
+          coverage.xml
+          htmlcov/
         retention-days: 30
         if-no-files-found: warn
 

conftest.py

@@ -1,23 +1,89 @@
 import pytest
 import allure
+import os
 from utils.api_utils import load_config
 
 
+def pytest_configure(config):
+    """
+    Initialize test configuration and environment.
+    """
+    config.addinivalue_line(
+        "markers",
+        "smoke: marks tests as smoke tests"
+    )
+    config.addinivalue_line(
+        "markers",
+        "user_retrieval: marks tests related to user retrieval operations"
+    )
+    config.addinivalue_line(
+        "markers",
+        "regression: marks tests as regression tests"
+    )
+    
+    # Create reports directory if it doesn't exist
+    import os
+    os.makedirs("reports", exist_ok=True)
+
+    # Create Allure environment properties file for reporting context
+    try:
+        config_data = load_config()
+        with open("reports/environment.properties", "w") as f:
+            f.write(f"BaseURL={config_data['environments'][config_data['env']]['base_url']}\n")
+            f.write("Framework=API Test Automation\n")
+            f.write("Language=Python\n")
+    except Exception:
+        # If config loading fails during pytest configure, skip environment file creation
+        pass
+
+
 @pytest.fixture(scope="session")
 def config():
     """
     Load and provide the entire config dictionary to tests.
+    Raises an error if configuration or schema files are missing.
     """
-    return load_config()
+    # Ensure config file exists
+    if not os.path.exists(os.path.join("config", "config.yaml")):
+        raise FileNotFoundError("config.yaml not found in config directory")
+
+    # Load config
+    config_data = load_config()
+
+    # Validate required config sections
+    required_sections = ["env", "environments", "timeout_seconds", "default_headers"]
+    for section in required_sections:
+        if section not in config_data:
+            raise KeyError(f"Missing required config section: {section}")
+
+    # Ensure schemas directory exists with required schemas
+    schemas_dir = os.path.join("schemas")
+    if not os.path.exists(schemas_dir):
+        raise FileNotFoundError("schemas directory not found")
+
+    required_schemas = ["user_list_schema.json"]
+    for schema in required_schemas:
+        if not os.path.exists(os.path.join(schemas_dir, schema)):
+            raise FileNotFoundError(f"Required schema file missing: {schema}")
+
+    return config_data
 
 
 @pytest.fixture(scope="session")
 def base_url(config):
     """
     Provide the base URL for the current environment.
+    Validates that the URL is properly configured.
     """
     env = config["env"]
-    return config["environments"][env]["base_url"]
+    if env not in config["environments"]:
+        raise KeyError(f"Environment '{env}' not found in config")
+    
+    url = config["environments"][env]["base_url"]
+    if not url:
+        raise ValueError(f"Base URL not configured for environment: {env}")
+    
+    return url
 
 
 @pytest.fixture(scope="function")
@@ -55,23 +121,4 @@ def attach_allure_logs(request):
             )
 
 
-def pytest_configure(config):
-    """
-    Pytest hook to customize test configuration.
-
-    - Sets up custom markers for smoke and regression tests.
-    - Generates Allure environment properties file for reporting.
-    """
-    # Register custom markers for test categorization
-    config.addinivalue_line("markers", "smoke: mark test as smoke test")
-    config.addinivalue_line("markers", "regression: mark test as regression test")
-
-    # Create reports directory if it doesn't exist
-    import os
-    os.makedirs("reports", exist_ok=True)
 
-    # Create Allure environment properties file for reporting context
-    with open("reports/environment.properties", "w") as f:
-        f.write(f"BaseURL={load_config()['environments'][load_config()['env']]['base_url']}\n")
-        f.write("Framework=API Test Automation\n")
-        f.write("Language=Python\n")

tests/test_user_retrieval.py

@@ -9,11 +9,7 @@
 import requests
 import allure
 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.user_retrieval
@@ -22,22 +18,26 @@
 @allure.feature("User Retrieval")
 @allure.title("GET List of Users")
 @allure.severity(allure.severity_level.NORMAL)
-def test_get_user_list():
+def test_get_user_list(base_url):
     """
     Test retrieving a paginated list of users.
     Validates response status and schema.
     """
     with allure.step("Send GET request to retrieve user list"):
-        url = f"{BASE_URL}/users?page=2"
+        url = f"{base_url}/users?page=2"
         response = requests.get(url, headers=get_headers())
 
     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}"
 
     with allure.step("Validate response against schema"):
         data = response.json()
-        schema = load_schema("user_list_schema.json")
-        validate(instance=data, schema=schema)
+        try:
+            schema = load_schema("user_list_schema.json")
+            validate(instance=data, schema=schema)
+        except Exception as e:
+            allure.attach(str(e), "Schema Validation Error", allure.attachment_type.TEXT)
+            raise
 
     with allure.step("Attach response details to report"):
         allure.attach(response.text, "Response Body", allure.attachment_type.JSON)
@@ -50,17 +50,17 @@ def test_get_user_list():
 @allure.title("GET Single User by ID")
 @allure.severity(allure.severity_level.CRITICAL)
 @pytest.mark.parametrize("user_id", [1, 2, 5])
-def test_get_single_user(user_id):
+def test_get_single_user(user_id, base_url):
     """
     Test retrieving a single user by ID.
     Validates response status and schema.
     """
     with allure.step(f"Send GET request to retrieve user {user_id}"):
-        url = f"{BASE_URL}/users/{user_id}"
+        url = f"{base_url}/users/{user_id}"
         response = requests.get(url, headers=get_headers())
 
     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}"
 
     with allure.step("Validate response against schema"):
         data = response.json()
@@ -81,17 +81,17 @@ def test_get_single_user(user_id):
 @allure.title("GET User List - Different Pages")
 @allure.severity(allure.severity_level.NORMAL)
 @pytest.mark.parametrize("page", [1, 2])
-def test_get_user_list_pagination(page):
+def test_get_user_list_pagination(page, base_url):
     """
     Test retrieving user lists from different pages.
     Validates pagination functionality.
     """
     with allure.step(f"Send GET request to retrieve page {page}"):
-        url = f"{BASE_URL}/users?page={page}"
+        url = f"{base_url}/users?page={page}"
         response = requests.get(url, headers=get_headers())
 
     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}"
 
     with allure.step("Validate response contains pagination info"):
         data = response.json()