Xray & Jira — Le Test Management Industrialisé

📂 Test Repository
├── 📁 Authentication
│   ├── 📁 Login
│   │   ├── 🧪 TC-001: Login with valid credentials
│   │   ├── 🧪 TC-002: Login with invalid password
│   │   └── 🧪 TC-003: Login with 2FA
│   ├── 📁 Registration
│   │   ├── 🧪 TC-010: Register new user
│   │   └── 🧪 TC-011: Register with existing email
│   └── 📁 Password Reset
│       └── 🧪 TC-020: Reset via email link
├── 📁 Cart & Checkout
│   ├── 📁 Cart Management
│   └── 📁 Payment Processing
├── 📁 Admin Panel
│   ├── 📁 User Management
│   └── 📁 Product Management
└── 📁 API Tests
    ├── 📁 REST Endpoints
    └── 📁 GraphQL Queries

Avantage : Aligné avec la structure fonctionnelle de l'application. Facile à naviguer pour les POs et les devs. Mappe naturellement sur les requirements.

📂 Test Repository
├── 📁 Functional Tests
│   ├── 📁 Smoke Tests
│   ├── 📁 Regression Tests
│   └── 📁 Integration Tests
├── 📁 Non-Functional Tests
│   ├── 📁 Performance Tests
│   ├── 📁 Security Tests
│   └── 📁 Accessibility Tests
├── 📁 E2E Tests
│   ├── 📁 Critical Paths
│   └── 📁 Edge Cases
└── 📁 Exploratory
    └── 📁 Session-based Charters

Avantage : Clair pour les équipes avec des testeurs spécialisés (perf, sécu, auto). Facilite le reporting par type de test.

Inconvénient : Un même scénario peut apparaître dans plusieurs catégories (un test de login est à la fois "fonctionnel" et "smoke"). Risque de duplication.

📂 Test Repository
├── 📁 Module A - Backend
│   ├── 📁 Unit Tests (auto - Generic)
│   ├── 📁 API Tests (auto - Generic)
│   └── 📁 Integration Tests (auto/manual)
├── 📁 Module B - Frontend
│   ├── 📁 Component Tests (auto - Cucumber)
│   ├── 📁 E2E Tests (auto - Generic)
│   └── 📁 Visual Regression (auto - Generic)
├── 📁 Cross-Module
│   ├── 📁 Smoke Suite
│   ├── 📁 Regression Suite
│   └── 📁 UAT Scenarios (manual)
└── 📁 Non-Functional
    ├── 📁 Performance
    └── 📁 Security

Avantage : Reflète l'architecture technique réelle. Chaque module owner gère ses tests. Scalable.

Draft : Test en cours de rédaction. Pas encore exécutable.

In Review : Soumis à un peer ou QA Lead pour validation des steps et expected results.

Approved : Prêt à être inclus dans un Test Plan et exécuté.

Deprecated : Obsolète mais conservé pour traçabilité historique.

Transition "Approved" → condition : seuls les rôles "QA Lead" ou "Test Manager" (organisations réglementées)

Simple et efficace. Le statut se met à jour automatiquement quand les Test Runs sont complétés. Pas besoin de complexifier.

Draft : Plan en préparation (sélection des tests, assignation).

Active : Sprint/release en cours, exécutions en cours.

Completed : Toutes les exécutions terminées, métriques finales.

Archived : Conservé pour l'historique, exclu des dashboards actifs.

1. Xray Test Case Importer (intégré) : Import CSV/Excel avec mapping wizard. Supporte HP ALM/QC v12.5x directement. Pour les versions plus anciennes : export CSV depuis ALM → import via l'importer.

2. ALM Xray Jumper (BRIGHTKNOCK) : Outil tiers spécialisé. Extraction des données via l'UI HP ALM, mapping pré-défini ALM→Xray, import via REST API Jira/Xray. Accès aux données ALM via OTA + tables DB + file repository. C'est l'option "industrielle" pour les gros volumes.

3. Scripts custom : Pour les cas complexes, un script Python/Java qui extrait via l'API ALM OTA et injecte via l'API REST Xray. Plus de contrôle, mais plus de travail.

Étape 1 : Export depuis TestLink au format XML

Étape 2 : Utiliser les scripts de conversion disponibles sur le GitHub Xray pour convertir XML → CSV

Étape 3 : Import CSV via le Test Case Importer Xray avec les fichiers de configuration JSON

Étape 4 : Validation post-import (vérifier steps, preconditions, liens)

1. Export des tests Zephyr en Excel/XML depuis l'interface Zephyr

2. Conversion du format via script (les custom step fields Zephyr ne sont pas directement supportés dans Xray — mapping vers "Additional step information")

3. Import via Test Case Importer avec le wizard de field mapping

4. Recréation manuelle des liens Test↔Requirement (les plus critiques)

5. Validation : comparer les comptages (nombre de tests, steps, liens) entre ancien et nouveau

Le Test Case Importer attend un CSV avec des colonnes spécifiques. Voici la structure recommandée :

CSV
"Test ID","Summary","Description","Priority","Labels","Step #","Action","Data","Expected Result"
"TC-001","Login avec identifiants valides","Vérifier le login standard","High","smoke,regression","1","Ouvrir la page de login","URL: /login","Page de login affichée"
"TC-001","","","","","2","Entrer email et mot de passe","user@test.com / Pass123","Champs remplis"
"TC-001","","","","","3","Cliquer sur 'Connexion'","","Redirection vers dashboard"
"TC-002","Login avec mot de passe invalide","Vérifier le rejet","High","smoke","1","Ouvrir la page de login","URL: /login","Page de login affichée"
"TC-002","","","","","2","Entrer email et mauvais mdp","user@test.com / bad","Message d'erreur affiché"

Règles critiques :

— Un test sur plusieurs lignes : la première ligne contient le Summary/Priority/Labels, les suivantes seulement les steps
— Séparez les CSV par type de test (Manual, Cucumber, Generic)
— Nettoyez les données AVANT l'import : supprimez les tests obsolètes, uniformisez les labels
— Utilisez un fichier de configuration JSON pour rendre l'import reproductible

1. Export depuis TestRail : Sections + Test Cases en CSV via l'interface d'admin

2. Attention aux templates TestRail : Step-by-Step, Plain Text, BDD-Gherkin — chacun a un format CSV différent

3. Import CSV via Test Case Importer Xray

4. Les custom fields TestRail doivent être recréés dans Jira puis mappés

5. Les test results historiques : export via API TestRail → import via API Xray (script custom nécessaire)

Bash
# Import basique — crée une Test Execution automatiquement
curl -X POST \
  "https://xray.cloud.getxray.app/api/v2/import/execution/junit?projectKey=PROJ" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/xml" \
  -d @target/surefire-reports/TEST-com.example.LoginTest.xml

# Import avec contexte enrichi
curl -X POST \
  "https://xray.cloud.getxray.app/api/v2/import/execution/junit?\
projectKey=PROJ&\
testPlanKey=PROJ-456&\
testEnvironments=Chrome%20120;Ubuntu%2024&\
fixVersion=3.2.0&\
revision=abc123def" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/xml" \
  -d @report.xml

Paramètres query :

Réponse :

JSON
{
  "testExecIssue": {
    "id": "12345",
    "key": "PROJ-789",
    "self": "https://your-jira.atlassian.net/rest/api/2/issue/12345"
  }
}

Bash
curl -X POST \
  "https://xray.cloud.getxray.app/api/v2/import/execution/cucumber" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d @target/cucumber-report.json

Python
# Import avec le format Xray JSON — contrôle total
import requests
import json
import base64

def import_xray_results(xray_client, results):
    """
    Import des résultats au format Xray JSON.
    Permet : evidence en base64, defects liés, commentaires,
    timestamps précis, infos enrichies.
    """
    payload = {
        "testExecutionKey": "PROJ-789",  # ou omis pour auto-création
        "info": {
            "project": "PROJ",
            "summary": f"Regression Suite - Build #{os.environ.get('BUILD_NUMBER', 'local')}",
            "description": "Exécution automatisée via pipeline CI",
            "startDate": "2026-02-10T09:00:00+01:00",
            "finishDate": "2026-02-10T09:45:00+01:00",
            "testPlanKey": "PROJ-456",
            "testEnvironments": ["Chrome 121", "Ubuntu 24.04"],
            "version": "3.2.0",
            "revision": "a1b2c3d4e5f6"
        },
        "tests": []
    }
    
    for test in results:
        test_entry = {
            "testKey": test["key"],
            "status": test["status"],  # PASSED, FAILED, TODO, EXECUTING, ABORTED
            "start": test["start_time"],
            "finish": test["end_time"],
            "comment": test.get("comment", ""),
        }
        
        # Ajouter des défauts liés si le test a échoué
        if test["status"] == "FAILED" and test.get("defect_key"):
            test_entry["defects"] = [test["defect_key"]]
        
        # Ajouter des preuves (screenshots) en base64
        if test.get("screenshot_path"):
            with open(test["screenshot_path"], "rb") as img:
                b64 = base64.b64encode(img.read()).decode()
            test_entry["evidences"] = [{
                "data": b64,
                "filename": f"evidence_{test['key']}.png",
                "contentType": "image/png"
            }]
        
        # Ajouter les résultats step par step
        if test.get("steps"):
            test_entry["steps"] = [
                {
                    "status": step["status"],
                    "comment": step.get("comment", ""),
                    "actualResult": step.get("actual_result", "")
                }
                for step in test["steps"]
            ]
        
        payload["tests"].append(test_entry)
    
    resp = xray_client.post("/import/execution", json=payload)
    resp.raise_for_status()
    result = resp.json()
    print(f"✅ Import OK → Test Execution: {result['testExecIssue']['key']}")
    return result

# Exemple d'appel
results = [
    {
        "key": "PROJ-100",
        "status": "PASSED",
        "start_time": "2026-02-10T09:00:00+01:00",
        "end_time": "2026-02-10T09:02:30+01:00",
        "comment": "All 5 assertions passed"
    },
    {
        "key": "PROJ-101",
        "status": "FAILED",
        "start_time": "2026-02-10T09:02:31+01:00",
        "end_time": "2026-02-10T09:05:00+01:00",
        "comment": "Expected HTTP 200, got 500 on /api/users",
        "defect_key": "PROJ-999",
        "screenshot_path": "/tmp/screenshots/error_PROJ-101.png",
        "steps": [
            {"status": "PASSED", "actual_result": "Login OK"},
            {"status": "PASSED", "actual_result": "Navigation OK"},
            {"status": "FAILED", "actual_result": "HTTP 500 Internal Server Error",
             "comment": "API /users returned 500 since build #1233"}
        ]
    }
]

xray = XrayCloudClient()
xray.authenticate()
import_xray_results(xray, results)

Bash
# Export par clés de test spécifiques
curl -X GET \
  "https://xray.cloud.getxray.app/api/v2/export/cucumber?keys=PROJ-200;PROJ-201;PROJ-202" \
  -H "Authorization: Bearer $TOKEN" \
  -o features.zip

unzip features.zip -d src/test/resources/features/

# Export par filtre JQL
curl -X GET \
  "https://xray.cloud.getxray.app/api/v2/export/cucumber?\
filter=12345" \
  -H "Authorization: Bearer $TOKEN" \
  -o features.zip

Paramètres :

Réponse : Fichier ZIP contenant les .feature avec les tags @PROJ-XXX automatiques.

Récupérer des tests avec leurs steps et préconditions

GraphQL
# POST https://xray.cloud.getxray.app/api/v2/graphql

{
    getTests(jql: "project = PROJ AND issuetype = Test", limit: 50) {
        total
        start
        limit
        results {
            issueId
            jira(fields: ["key", "summary", "status", "priority", "labels"])
            testType { name kind }
            folder { path name }
            steps {
                id
                action
                data
                result
                attachments { id filename }
            }
            preconditions(limit: 10) {
                results {
                    issueId
                    jira(fields: ["key", "summary"])
                    definition
                    preconditionType { name }
                }
            }
            testRuns(limit: 5) {
                results {
                    id
                    status { name color }
                    startedOn
                    finishedOn
                    executedById
                    testExecution { issueId jira(fields: ["key"]) }
                    evidence { filename }
                    defects { issueId jira(fields: ["key", "summary", "status"]) }
                    comment
                }
            }
        }
    }
}

Récupérer la couverture d'un Test Plan

GraphQL
{
    getTestPlan(issueId: "12345") {
        issueId
        jira(fields: ["key", "summary"])
        tests(limit: 100) {
            total
            results {
                issueId
                jira(fields: ["key", "summary"])
                testType { name }
                lastTestRunStatus
            }
        }
        testExecutions(limit: 20) {
            results {
                issueId
                jira(fields: ["key", "summary", "status"])
                testEnvironments
                testRuns(limit: 100) {
                    results {
                        status { name }
                        startedOn
                        finishedOn
                    }
                }
            }
        }
    }
}

Récupérer la couverture des requirements

GraphQL
{
    getTests(jql: "issuetype = Test AND project = PROJ", limit: 100) {
        results {
            issueId
            jira(fields: ["key", "summary"])
            testType { name }
            # Les requirements couverts par ce test
            requirements(limit: 10) {
                results {
                    issueId
                    jira(fields: ["key", "summary", "status"])
                }
            }
            lastTestRunStatus
        }
    }
}

Implémentation Python complète

Python
def graphql_query(xray_client, query, variables=None):
    """Exécuter une requête GraphQL sur Xray Cloud."""
    payload = {"query": query}
    if variables:
        payload["variables"] = variables
    
    resp = xray_client.post("/graphql", json=payload)
    resp.raise_for_status()
    data = resp.json()
    
    if "errors" in data:
        for err in data["errors"]:
            print(f"⚠️ GraphQL Error: {err['message']}")
    
    return data.get("data", {})

# Exemple : Dashboard de couverture en une requête
COVERAGE_QUERY = """
{
    getTests(jql: "project = PROJ AND issuetype = Test", limit: 200) {
        total
        results {
            issueId
            jira(fields: ["key", "summary"])
            testType { name }
            lastTestRunStatus
            requirements(limit: 5) {
                results {
                    jira(fields: ["key", "summary"])
                }
            }
        }
    }
}
"""

xray = XrayCloudClient()
xray.authenticate()
data = graphql_query(xray, COVERAGE_QUERY)

tests = data["getTests"]["results"]
total = data["getTests"]["total"]

# Calculer les stats
passed = sum(1 for t in tests if t.get("lastTestRunStatus") == "PASSED")
failed = sum(1 for t in tests if t.get("lastTestRunStatus") == "FAILED")
no_run = sum(1 for t in tests if not t.get("lastTestRunStatus"))
orphans = sum(1 for t in tests if not t.get("requirements", {}).get("results"))

print(f"📊 Dashboard Xray — {total} tests")
print(f"   ✅ Passed:  {passed} ({passed/total*100:.0f}%)")
print(f"   ❌ Failed:  {failed} ({failed/total*100:.0f}%)")
print(f"   ⬜ No runs: {no_run} ({no_run/total*100:.0f}%)")
print(f"   🔗 Orphans: {orphans} ({orphans/total*100:.0f}%) ← sans requirement")

Python
class TestRunManager:
    """Gestion avancée des Test Runs via API Xray."""
    
    def __init__(self, xray_client):
        self.xray = xray_client
    
    def update_status(self, test_run_id, status, comment=None):
        """
        Modifier le statut d'un Test Run.
        Statuts possibles : PASSED, FAILED, TODO, EXECUTING, ABORTED
        """
        payload = {"status": status}
        if comment:
            payload["comment"] = comment
        
        resp = self.xray.put(f"/testrun/{test_run_id}/status", json=payload)
        resp.raise_for_status()
        print(f"✅ Test Run {test_run_id} → {status}")
    
    def add_evidence(self, test_run_id, filepath, content_type="image/png"):
        """Attacher une evidence (screenshot, log) au Test Run."""
        with open(filepath, "rb") as f:
            files = {"file": (os.path.basename(filepath), f, content_type)}
            resp = requests.post(
                f"{self.xray.BASE_URL}/testrun/{test_run_id}/attachment",
                headers={"Authorization": f"Bearer {self.xray.token}"},
                files=files
            )
        resp.raise_for_status()
        print(f"📎 Evidence ajoutée au Test Run {test_run_id}")
    
    def link_defect(self, test_run_id, defect_key):
        """Lier un défaut Jira à un Test Run."""
        resp = self.xray.post(
            f"/testrun/{test_run_id}/defect",
            json={"issueKey": defect_key}
        )
        resp.raise_for_status()
        print(f"🐛 Defect {defect_key} lié au Test Run {test_run_id}")
    
    def add_comment(self, test_run_id, comment):
        """Ajouter un commentaire au Test Run."""
        resp = self.xray.put(
            f"/testrun/{test_run_id}/comment",
            json={"comment": comment}
        )
        resp.raise_for_status()

# Usage dans un framework de test custom
runner = TestRunManager(xray)

# Après un test qui échoue
runner.update_status("tr-12345", "FAILED", "Timeout on API call after 30s")
runner.add_evidence("tr-12345", "/tmp/screenshots/api_timeout.png")
runner.link_defect("tr-12345", "PROJ-999")
runner.add_comment("tr-12345", "Reproduced consistently since build #1233")

Python
"""
Listener Xray — Serveur webhook qui réagit aux événements Jira/Xray.
Configure un webhook Jira pointant vers ce serveur.

Jira Admin → System → Webhooks → Create
URL: https://your-server.com/webhook/xray
Events: Issue created, Issue updated
JQL Filter: issuetype in (Test, "Test Execution", Bug)
"""

from flask import Flask, request, jsonify
import requests
import json
from datetime import datetime

app = Flask(__name__)

# Configuration
SLACK_WEBHOOK = "https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK"
XRAY_EVENTS_LOG = "xray_events.log"

def log_event(event_type, data):
    """Logger tous les événements pour audit."""
    with open(XRAY_EVENTS_LOG, "a") as f:
        f.write(json.dumps({
            "timestamp": datetime.now().isoformat(),
            "type": event_type,
            "data": data
        }) + "\n")

def notify_slack(message, color="#FF5630"):
    """Envoyer une notification Slack."""
    requests.post(SLACK_WEBHOOK, json={
        "attachments": [{
            "color": color,
            "text": message,
            "footer": "Xray Listener",
            "ts": int(datetime.now().timestamp())
        }]
    })

@app.route("/webhook/xray", methods=["POST"])
def xray_webhook():
    """Point d'entrée principal du webhook."""
    payload = request.json
    
    event = payload.get("webhookEvent", "unknown")
    issue = payload.get("issue", {})
    issue_type = issue.get("fields", {}).get("issuetype", {}).get("name", "")
    issue_key = issue.get("key", "N/A")
    summary = issue.get("fields", {}).get("summary", "")
    
    log_event(event, {"key": issue_key, "type": issue_type})
    
    # === ÉVÉNEMENT 1 : Test Execution créée ===
    if event == "jira:issue_created" and issue_type == "Test Execution":
        assignee = issue.get("fields", {}).get("assignee", {}).get("displayName", "Non assigné")
        notify_slack(
            f"▶️ Nouvelle Test Execution : *{issue_key}* — {summary}\n"
            f"Assigné à : {assignee}",
            color="#0052CC"
        )
    
    # === ÉVÉNEMENT 2 : Bug créé depuis un Test Run ===
    elif event == "jira:issue_created" and issue_type == "Bug":
        priority = issue.get("fields", {}).get("priority", {}).get("name", "?")
        # Vérifier si le bug est lié à un test (via issuelinks)
        links = issue.get("fields", {}).get("issuelinks", [])
        test_links = [
            l for l in links 
            if l.get("type", {}).get("name") == "is blocked by"
        ]
        if test_links:
            test_key = test_links[0].get("outwardIssue", {}).get("key", "?")
            notify_slack(
                f"🐛 Bug créé depuis un test !\n"
                f"Bug : *{issue_key}* ({priority}) — {summary}\n"
                f"Test source : {test_key}",
                color="#DE350B"
            )
    
    # === ÉVÉNEMENT 3 : Test Execution terminée ===
    elif event == "jira:issue_updated" and issue_type == "Test Execution":
        new_status = payload.get("changelog", {}).get("items", [{}])
        for change in payload.get("changelog", {}).get("items", []):
            if change.get("field") == "status" and change.get("toString") == "Done":
                notify_slack(
                    f"✅ Test Execution terminée : *{issue_key}* — {summary}\n"
                    f"📊 Résultats disponibles dans Xray",
                    color="#36B37E"
                )
    
    # === ÉVÉNEMENT 4 : Test passé en status Deprecated ===
    elif event == "jira:issue_updated" and issue_type == "Test":
        for change in payload.get("changelog", {}).get("items", []):
            if change.get("field") == "status" and change.get("toString") == "Deprecated":
                notify_slack(
                    f"🗄️ Test archivé : *{issue_key}* — {summary}\n"
                    f"Vérifiez qu'il est retiré des Test Plans actifs.",
                    color="#97A0AF"
                )
    
    return jsonify({"status": "ok"}), 200

@app.route("/webhook/ci-trigger", methods=["POST"])
def ci_trigger():
    """
    Endpoint pour déclencher un pipeline CI
    quand un Test Plan passe en status 'Active'.
    """
    payload = request.json
    issue = payload.get("issue", {})
    issue_type = issue.get("fields", {}).get("issuetype", {}).get("name", "")
    
    if issue_type == "Test Plan":
        for change in payload.get("changelog", {}).get("items", []):
            if change.get("field") == "status" and change.get("toString") == "Active":
                test_plan_key = issue.get("key")
                # Déclencher le pipeline Jenkins
                requests.post(
                    "https://jenkins.example.com/job/regression-suite/build",
                    auth=("jenkins_user", "jenkins_token"),
                    json={"parameter": [
                        {"name": "TEST_PLAN_KEY", "value": test_plan_key}
                    ]}
                )
                notify_slack(
                    f"🚀 Pipeline déclenché pour Test Plan *{test_plan_key}*",
                    color="#0052CC"
                )
    
    return jsonify({"status": "ok"}), 200

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=False)

Jira Automation Rules
# Règle 1 : Notifier Slack quand un test échoue
TRIGGER: Issue updated
CONDITION: Issue type = "Test Execution" AND Status changed to "Done"
ACTION: Send Slack message → "#qa-alerts"
         Message: "Test Execution {{issue.key}} terminée — vérifiez les résultats"

# Règle 2 : Assigner les bugs auto-créés au tech lead
TRIGGER: Issue created
CONDITION: Issue type = Bug AND Issue has link type "is created by"
ACTION: Assign to → "tech.lead@company.com"

# Règle 3 : Ajouter un commentaire quand la couverture est OK
TRIGGER: Field value changed
CONDITION: Field "Requirement Status" = OK
ACTION: Add comment → "✅ Couverture validée — tous les tests passent"

# Règle 4 : Transition auto du Test Plan quand toutes les exécutions sont Done
TRIGGER: Issue updated (Test Execution → Done)
CONDITION: Related Test Plan has all Test Executions in Done
ACTION: Transition Test Plan → "Completed"

Python
"""
Script de rapport quotidien de couverture Xray.
À exécuter via cron ou CI schedule.
Envoie un résumé Slack + génère un JSON pour dashboard.
"""

import requests
import json
from datetime import datetime

def generate_coverage_report(xray_client, project_key, version=None):
    """Générer un rapport de couverture complet."""
    
    # 1. Récupérer les tests et leur statut via GraphQL
    jql = f"project = {project_key} AND issuetype = Test"
    if version:
        jql += f" AND fixVersion = '{version}'"
    
    query = """
    query($jql: String!) {
        getTests(jql: $jql, limit: 500) {
            total
            results {
                issueId
                jira(fields: ["key", "summary", "labels"])
                testType { name }
                lastTestRunStatus
                requirements(limit: 5) {
                    total
                    results { jira(fields: ["key"]) }
                }
            }
        }
    }
    """
    
    data = graphql_query(xray_client, query, {"jql": jql})
    tests = data.get("getTests", {}).get("results", [])
    total = data.get("getTests", {}).get("total", 0)
    
    # 2. Calculer les métriques
    stats = {
        "date": datetime.now().isoformat(),
        "project": project_key,
        "version": version,
        "total_tests": total,
        "by_status": {},
        "by_type": {},
        "orphan_tests": 0,  # Tests sans requirement
        "coverage_rate": 0
    }
    
    for test in tests:
        # Par statut
        status = test.get("lastTestRunStatus") or "NO_RUN"
        stats["by_status"][status] = stats["by_status"].get(status, 0) + 1
        
        # Par type
        test_type = test.get("testType", {}).get("name", "Unknown")
        stats["by_type"][test_type] = stats["by_type"].get(test_type, 0) + 1
        
        # Orphelins
        req_count = test.get("requirements", {}).get("total", 0)
        if req_count == 0:
            stats["orphan_tests"] += 1
    
    # Taux de couverture = tests liés à au moins 1 requirement
    linked = total - stats["orphan_tests"]
    stats["coverage_rate"] = round((linked / total * 100), 1) if total > 0 else 0
    
    # Pass rate
    passed = stats["by_status"].get("PASSED", 0)
    executed = total - stats["by_status"].get("NO_RUN", 0)
    stats["pass_rate"] = round((passed / executed * 100), 1) if executed > 0 else 0
    
    # 3. Générer le message Slack
    status_emoji = "✅" if stats["pass_rate"] > 85 else "⚠️" if stats["pass_rate"] > 70 else "🔴"
    
    slack_message = f"""
{status_emoji} *Rapport QA Quotidien — {project_key}*
📅 {datetime.now().strftime('%d/%m/%Y %H:%M')}
{'Version: ' + version if version else ''}

📊 *Métriques :*
• Tests total : {total}
• ✅ Passed : {stats['by_status'].get('PASSED', 0)}
• ❌ Failed : {stats['by_status'].get('FAILED', 0)}
• ⬜ Non exécutés : {stats['by_status'].get('NO_RUN', 0)}
• 🔗 Taux de couverture : {stats['coverage_rate']}%
• 📈 Pass rate : {stats['pass_rate']}%
• 👻 Tests orphelins : {stats['orphan_tests']}

🧪 *Par type :*
{chr(10).join(f"• {k}: {v}" for k, v in stats['by_type'].items())}
"""
    
    return stats, slack_message

# Exécution
xray = XrayCloudClient()
xray.authenticate()

stats, message = generate_coverage_report(xray, "PROJ", "3.2.0")

# Envoyer sur Slack
requests.post(SLACK_WEBHOOK, json={"text": message})

# Sauvegarder le JSON pour historique
with open(f"reports/coverage_{datetime.now().strftime('%Y%m%d')}.json", "w") as f:
    json.dump(stats, f, indent=2)

print(f"✅ Rapport généré — Pass rate: {stats['pass_rate']}%")

Python
"""
Script de nettoyage : identifier et labelliser les tests orphelins.
Orphelin = test sans requirement lié ET sans exécution depuis 6 mois.
"""

from datetime import datetime, timedelta

def find_orphan_tests(xray_client, project_key, months_inactive=6):
    """Trouver les tests orphelins et inactifs."""
    
    cutoff = (datetime.now() - timedelta(days=months_inactive * 30)).strftime("%Y-%m-%d")
    
    query = """
    query($jql: String!) {
        getTests(jql: $jql, limit: 200) {
            total
            results {
                issueId
                jira(fields: ["key", "summary", "created", "updated", "labels"])
                testType { name }
                requirements(limit: 1) { total }
                testRuns(limit: 1) {
                    results {
                        startedOn
                        status { name }
                    }
                }
            }
        }
    }
    """
    
    jql = f"project = {project_key} AND issuetype = Test AND updated <= '{cutoff}'"
    data = graphql_query(xray_client, query, {"jql": jql})
    
    orphans = []
    for test in data.get("getTests", {}).get("results", []):
        has_requirements = test.get("requirements", {}).get("total", 0) > 0
        has_recent_runs = len(test.get("testRuns", {}).get("results", [])) > 0
        
        if not has_requirements and not has_recent_runs:
            key = test["jira"]["key"]
            summary = test["jira"]["summary"]
            orphans.append({"key": key, "summary": summary})
            print(f"  👻 {key}: {summary}")
    
    print(f"\n📊 {len(orphans)} tests orphelins sur {data['getTests']['total']} inactifs")
    return orphans

# Pour chaque orphelin, ajouter le label DEPRECATED via API Jira
def label_orphans(orphans, jira_base_url, jira_auth):
    """Ajouter le label DEPRECATED aux tests orphelins."""
    for test in orphans:
        requests.put(
            f"{jira_base_url}/rest/api/2/issue/{test['key']}",
            auth=jira_auth,
            json={"update": {"labels": [{"add": "DEPRECATED"}]}}
        )
        print(f"  🏷️ {test['key']} → DEPRECATED")

orphans = find_orphan_tests(xray, "PROJ", months_inactive=6)
# label_orphans(orphans, "https://your-jira.atlassian.net", ("email", "api_token"))