robo-automation-test-kit 1.0.0__py3-none-any.whl

robo_automation_test_kit/utils/RoboHelper.py

@@ -0,0 +1,420 @@
+# Report generation utilities and helpers
+from .reports.HtmlReportUtils import get_html_template
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader
+from datetime import datetime
+import zipfile
+import os
+import logging
+import shutil
+
+
+logger = logging.getLogger(__name__)
+logger.propagate = True
+
+
+def profile_name_from_driver(driver) -> str:
+
+    # Log profile name from driver user-data-dir argument
+    profile_name: str = ""
+    for arg in driver.options.arguments:
+        if arg.startswith("--user-data-dir="):
+            profile_dir = arg.split("=", 1)[1]
+            profile_name = os.path.basename(profile_dir)
+            break
+
+    return profile_name
+
+
+def load_test_data(path: Path):
+    """Load test data rows from CSV or Excel file using pandas.
+
+    Supports multiple file formats and encodings:
+    - CSV files with utf-8-sig, latin-1, or utf-8 encoding
+    - Excel workbooks (.xlsx)
+
+    Returns a list of dict rows suitable for pytest parametrization.
+    """
+
+    # Print to stderr to ensure visibility in xdist mode
+    import sys
+
+    # Validate file exists
+    if not os.path.exists(path):
+        logger.error(f"Data file not found: {path}")
+        return []
+
+    try:
+        import pandas as pd
+    except ImportError:
+        logger.error("pandas not installed; cannot load data file")
+        return []
+
+    try:
+        if zipfile.is_zipfile(path):
+            df = pd.read_excel(
+                path, engine="openpyxl", dtype=str, keep_default_na=False
+            )
+        else:
+            df = None
+            for enc in ("utf-8-sig", "latin-1", "utf-8"):
+                try:
+                    df = pd.read_csv(
+                        path, encoding=enc, dtype=str, keep_default_na=False
+                    )
+                    break
+                except UnicodeDecodeError:
+                    df = None
+            if df is None:
+                logger.error(
+                    f"Could not load CSV file {path} with any supported encoding"
+                )
+                return []
+        df = df.fillna("")
+
+        return df.to_dict(orient="records")
+    except Exception as exc:
+        logger.error(f"Error loading data file {path}: {exc}", exc_info=True)
+        return []
+
+
+def get_env(key: str, default: str = "") -> str:
+    value = os.getenv(key, default).strip()
+    return value if value else default
+
+
+def extract_test_case_name_from_docstring(item, report):
+    """Extract test case name from function docstring or nodeid."""
+    docstring = str(item.function.__doc__)
+    if docstring:
+        return docstring.strip()
+    else:
+        return report.nodeid
+
+
+def print_results_summary(all_results):
+
+    header = "{:<10} {:<30} {:<10} {:<10} {:<20} {:<20} {:<10} {:<10} {:<20}".format(
+        "Status",
+        "Title",
+        "Phase",
+        "Request Category",
+        "Request Sub Category",
+        "Center",
+        "Duration",
+        "Error Log",
+        "Test Name",
+    )
+    sep = "-" * 150
+    print("\nTest Results Summary:")
+    print(header)
+    print(sep)
+    if not all_results:
+        print(sep)
+        return
+    for result in all_results:
+        # If duration is a float or int, format as HH:MM:SS
+        duration_val = result.get("duration", "")
+        if isinstance(duration_val, (float, int)):
+            hours = int(duration_val // 3600)
+            minutes = int((duration_val % 3600) // 60)
+            seconds = int(duration_val % 60)
+            duration_str = f"{hours:02}:{minutes:02}:{seconds:02}"
+        else:
+            duration_str = str(duration_val)
+        row = "{:<10} {:<30} {:<10} {:<10} {:<20} {:<20} {:<10} {:<10} {:<20}".format(
+            result.get("test_status", ""),
+            result.get("title", ""),
+            result.get("Phase", ""),
+            result.get("Request Category", ""),
+            result.get("Request Sub Category", ""),
+            result.get("Center", ""),
+            duration_str,
+            result.get("error_log", ""),
+            result.get("test_name", ""),
+        )
+        print(row)
+    print(sep)
+
+
+# Flatten if results is a list of lists or dicts
+def flatten_results(res, cfg):
+    """Flatten and aggregate test results from workers."""
+    if cfg is None:
+        return
+    if isinstance(res, dict):
+        cfg._test_results_from_workers.append(res)
+    elif isinstance(res, list):
+        for x in res:
+            flatten_results(x, cfg)
+    else:
+        pass
+
+
+def build_test_data(item):
+    """
+    Build test result data dictionary from test execution information.
+
+    Args:
+        item: pytest Item object containing test metadata
+        custom_attribute_data: Optional dict with custom attributes from robo_custom_attribute_data hook
+
+    Returns:
+        Dictionary containing test result data:
+        - test_status: PASSED, FAILED, or SKIPPED
+        - test_id: Test name/nodeid
+        - error_log: Exception message if test failed
+        - duration: Total execution time in seconds (sum of all phases)
+        - Any additional fields from custom_attributes dict
+    """
+
+    # Get stored call phase exception info
+    call_excinfo = getattr(item, "_call_excinfo", None)
+
+    # Determine test status and error log from call phase
+    if call_excinfo is None:
+        status = "PASSED"
+        error_log = ""
+    else:
+        # Safely extract error message
+        try:
+            error_repr = call_excinfo.getrepr()
+            error_log = (
+                error_repr.reprcrash.message
+                if error_repr.reprcrash
+                else str(call_excinfo.value)
+            )
+        except (AttributeError, Exception):
+            error_log = (
+                str(call_excinfo.value) if call_excinfo.value else "Unknown error"
+            )
+
+        # Determine status based on exception type
+        if call_excinfo.typename == "Skipped":
+            status = "SKIPPED"
+        else:
+            status = "FAILED"
+    # Calculate total duration (setup + call + teardown)
+    total_duration = sum(item._phase_durations.values())
+
+    test_id = getattr(item, "name", item.nodeid)
+
+    data_row = {
+        # "test_case_name": test_case_name,
+        "test_status": status,
+        "test_id": test_id,
+        "error_log": error_log,
+        "duration": total_duration,
+    }
+
+    return data_row
+
+
+# ============================================================================
+# Report Generation Functions (merged from report_generator.py)
+# ============================================================================
+
+
+def aggregate_test_results(config):
+    """
+    Aggregate test results from master process and xdist workers.
+
+    Collects results from config.test_results_summary (master process)
+    and config._test_results_from_workers (aggregated worker results).
+
+    Args:
+        config: Pytest config object
+
+    Returns:
+        List of aggregated test result dictionaries
+    """
+    report_rows = []
+
+    # Include results from config.test_results_summary (initialized in pytest_configure)
+    if hasattr(config, "test_results_summary") and config.test_results_summary:
+        master_results = [r for r in config.test_results_summary if isinstance(r, dict)]
+        report_rows.extend(master_results)
+
+    # Include results from xdist workers (aggregated via pytest_testnodedown)
+    if (
+        hasattr(config, "_test_results_from_workers")
+        and config._test_results_from_workers
+    ):
+        for entry in config._test_results_from_workers:
+            if isinstance(entry, dict):
+                report_rows.append(entry)
+            elif isinstance(entry, list):
+                worker_results = [r for r in entry if isinstance(r, dict)]
+                report_rows.extend(worker_results)
+    
+    return report_rows
+
+
+def create_report_summary(report_rows, start_time=None):
+    """
+    Create summary object for HTML report template.
+
+    Args:
+        report_rows: List of test result dictionaries
+        start_time: Datetime object for test session start
+
+    Returns:
+        Dictionary containing summary statistics for the report
+    """
+    # Calculate test duration
+    if start_time:
+        end_time = datetime.now()
+        duration = end_time - start_time
+        duration_str = str(duration).split(".")[0]  # Remove microseconds
+    else:
+        duration_str = ""
+
+    # Calculate summary statistics
+    total = len(report_rows)
+    passed = sum(1 for r in report_rows if r.get("test_status") == "PASSED")
+    failed = sum(1 for r in report_rows if r.get("test_status") in ["ERROR", "FAILED"])
+    skipped = sum(1 for r in report_rows if r.get("test_status") == "SKIPPED")
+
+    return {
+        "env_name": os.getenv("APP_ENV", "").upper(),
+        "project_name": os.getenv("PROJECT_NAME", ""),
+        "test_framework": os.getenv("TEST_FRAMEWORK", "Robo Automation Framework"),
+        "total": total,
+        "duration": duration_str,
+        "passed": passed,
+        "failed": failed,
+        "skipped": skipped,
+        "rerun": 0,  # Not tracked in current implementation
+        "generated_date": datetime.now().strftime("%m-%d-%Y"),
+        "generated_time": datetime.now().strftime("%I:%M:%S %p"),
+    }
+
+
+def format_duration(seconds):
+    """
+    Convert duration in seconds to HH:MM:SS format string.
+
+    Args:
+        seconds: Duration in seconds (float or int)
+
+    Returns:
+        Formatted duration string as HH:MM:SS
+    """
+    if isinstance(seconds, (float, int)):
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        secs = int(seconds % 60)
+        return f"{hours:02}:{minutes:02}:{secs:02}"
+    return str(seconds)
+
+
+def get_report_path():
+    """
+    Determine and create the report path from environment configuration.
+
+    Returns:
+        Path object for the HTML report file location
+    """
+    report_path = get_env("REPORT_PATH", "reports")
+    report_dir = Path(report_path)
+    report_dir.mkdir(parents=True, exist_ok=True)
+    return report_dir / "test_report.html"
+
+
+def generate_report(report_rows, report_summary, start_time):
+    """
+    Generate and save HTML report with test results.
+
+    Args:
+        report_rows: List of test result dictionaries
+        report_summary: Summary dictionary for the report
+        start_time: Datetime object for test session start
+
+    Returns:
+        Path to the generated HTML report
+    """
+
+    # Prepare template data with raw numeric durations
+    report_title = get_env("REPORT_TITLE", "Test Execution Report")
+    template_data = {
+        "report_title": report_title,
+        "summary": report_summary,
+        "report_rows": report_rows,
+    }
+
+    # Load CSS and JS files for embedding
+    try:
+        scripts_dir = Path(__file__).parent.parent / "templates" / "html_report" / "scripts"
+
+        # Read CSS files
+        css_path = scripts_dir / "css" / "report.css"
+        css_content = css_path.read_text(encoding="utf-8") if css_path.exists() else ""
+
+        material_icons_path = scripts_dir / "css" / "material-icons.css"
+        material_icons_content = (
+            material_icons_path.read_text(encoding="utf-8")
+            if material_icons_path.exists()
+            else ""
+        )
+
+        robo_fonts_path = scripts_dir / "css" / "robo-fonts.css"
+        robo_fonts_content = (
+            robo_fonts_path.read_text(encoding="utf-8")
+            if robo_fonts_path.exists()
+            else ""
+        )
+
+        # Read Chart.js library
+        chart_js_path = scripts_dir / "js" / "chart.js"
+        chart_js_content = (
+            chart_js_path.read_text(encoding="utf-8")
+            if chart_js_path.exists()
+            else ""
+        )
+
+        # Read merged JS file
+        report_js_path = scripts_dir / "js" / "report.js"
+
+        report_js_content = (
+            report_js_path.read_text(encoding="utf-8")
+            if report_js_path.exists()
+            else ""
+        )
+
+        # Add to template data
+        template_data["embedded_css"] = css_content
+        template_data["embedded_material_icons"] = material_icons_content
+        template_data["embedded_robo_fonts"] = robo_fonts_content
+        template_data["embedded_chart_js"] = chart_js_content
+        template_data["embedded_report_js"] = report_js_content
+    except Exception as e:
+        # If reading fails, use empty strings
+        template_data["embedded_css"] = ""
+        template_data["embedded_material_icons"] = ""
+        template_data["embedded_robo_fonts"] = ""
+        template_data["embedded_chart_js"] = ""
+        template_data["embedded_report_js"] = ""
+
+    # Load template using get_html_template() which checks source first
+    template = get_html_template()
+    
+    # Register custom Jinja2 filter for duration formatting
+    template.globals['format_duration'] = format_duration
+
+    # Render and save report
+    try:
+        html_content = template.render(**template_data)
+
+        report_path = get_report_path()
+
+        with open(report_path, "w", encoding="utf-8") as f:
+            f.write(html_content)
+
+        print(f"\nHTML report generated: {report_path.absolute()}", flush=True)
+        return str(report_path.absolute())
+    except Exception as e:
+        print(f"\nError generating HTML report: {e}", flush=True)
+        import traceback
+
+        traceback.print_exc()
+        return None

robo_automation_test_kit/utils/__init__.py

@@ -0,0 +1,19 @@
+"""
+Utility functions for robo-reporter
+"""
+
+from .RoboHelper import (
+    load_test_data,
+    get_env,
+    extract_test_case_name_from_docstring,
+    print_results_summary,
+    flatten_results,
+)
+
+__all__ = [
+    'load_test_data',
+    'get_env',
+    'extract_test_case_name_from_docstring',
+    'print_results_summary',
+    'flatten_results',
+]

robo_automation_test_kit/utils/reports/HtmlReportUtils.py

@@ -0,0 +1,154 @@
+def get_report_data(start_time):
+    """
+    Build the report_data dictionary for report generation, using config and environment variables.
+    """
+    import os
+    from datetime import datetime
+
+    project_root = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "..", "..", "..")
+    )
+    report_dir = os.path.join(project_root, "reports")
+    return {
+        "project_name": os.getenv("PROJECT_NAME", ""),
+        "env_name": os.getenv("APP_ENV", ""),
+        "test_framework": os.getenv("TEST_FRAMEWORK", "Robo Automation Framework"),
+        "start_time": start_time,
+        "end_time": datetime.now(),
+        "report_dir": report_dir,
+    }
+
+
+import os
+
+
+def get_html_template():
+    """
+    Returns the Jinja2 template object for the HTML report.
+    Checks for source template in project working directory first, then falls back to package template.
+    """
+    import os
+    from jinja2 import Environment, FileSystemLoader
+    from pathlib import Path
+
+    # Check for source template in current working directory only
+    source_template_dir = Path.cwd() / "templates" / "html_report"
+    source_template_file = source_template_dir / "html_template.html"
+    
+    if source_template_file.exists():
+        # print(f"Loading source template from: {source_template_dir}", flush=True)
+        env = Environment(loader=FileSystemLoader(str(source_template_dir)))
+        return env.get_template("html_template.html")
+    
+    # Fall back to package template inside robo_automation_test_kit directory
+    package_root = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "..", "..")
+    )
+    package_template_dir = os.path.join(package_root, "templates", "html_report")
+    env = Environment(loader=FileSystemLoader(package_template_dir))
+    return env.get_template("html_template.html")
+
+
+
+def get_report_summary(all_results, report_data):
+    """
+    Create the summary object for the report, including environment, project, test framework, total, and duration.
+    """
+    from datetime import datetime
+    start_time = report_data.get("start_time", None)
+    end_time = report_data.get("end_time", None)
+    if start_time is not None and end_time is not None:
+        total_seconds = int((end_time - start_time).total_seconds())
+        hours = total_seconds // 3600
+        minutes = (total_seconds % 3600) // 60
+        seconds = total_seconds % 60
+        duration_str = f"{hours:02}:{minutes:02}:{seconds:02}"
+    else:
+        duration_str = "-"
+
+    # Count test statuses for summary chart, treating 'ERROR' as 'FAILED'
+    status_counts = {"PASSED": 0, "FAILED": 0, "SKIPPED": 0, "RERUN": 0}
+    for result in all_results:
+        status = str(result.get("test_status", "")).upper()
+        if status == "ERROR":
+            status = "FAILED"
+        if status in status_counts:
+            status_counts[status] += 1
+    return {
+        "env_name": report_data.get("env_name", ""),
+        "project_name": report_data.get("project_name", ""),
+        "test_framework": report_data.get("test_framework", ""),
+        "total": len(all_results),
+        "duration": duration_str,
+        "passed": status_counts["PASSED"],
+        "failed": status_counts["FAILED"],
+        "skipped": status_counts["SKIPPED"],
+        "rerun": status_counts["RERUN"],
+        "generated_date": datetime.now().strftime('%m-%d-%Y'),
+        "generated_time": datetime.now().strftime('%I:%M:%S %p'),
+    }
+
+
+def generate_and_save_html_report(all_results, start_time):
+    """
+    Generate and save the HTML report in the report directory with a timestamped filename.
+    Returns the path to the generated report.
+    """
+
+    report_data = get_report_data(start_time)
+
+    report_title = report_data.get("project_name", "NA")
+    report_dir = report_data.get("report_dir", None)
+
+    if report_dir is None:
+        # Use the project root (three levels up from this file)
+        project_root = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), "..", "..", "..")
+        )
+        report_dir = os.path.join(project_root, "reports")
+    os.makedirs(report_dir, exist_ok=True)
+
+    # Sanitize report_title for filename (remove/replace problematic characters)
+    import re
+    from datetime import datetime
+
+    safe_title = re.sub(r"[^a-zA-Z0-9_-]", "_", report_title)
+    now_str = datetime.now().strftime("_%Y%m%d_%H%M%S")
+    html_report_path = os.path.join(report_dir, f"{safe_title}{now_str}.html")
+    generate_html_report(all_results, html_report_path, report_data)
+    return html_report_path
+
+
+def generate_html_report(all_results, output_path, report_data=None):
+    """
+    Generate an HTML report using the Jinja2 template and all_results.
+    """
+
+    # Defensive: allow report_data to be None
+    if report_data is None:
+        report_data = {}
+    report_title = os.getenv("REPORT_TITLE", "Test Report")
+    from datetime import datetime
+    summary = get_report_summary(all_results, report_data)
+
+    template = get_html_template()
+    
+    # Create format_duration function and register it with template
+    def format_duration_func(seconds):
+        if isinstance(seconds, (float, int)):
+            hours = int(seconds // 3600)
+            minutes = int((seconds % 3600) // 60)
+            secs = int(seconds % 60)
+            return f"{hours:02}:{minutes:02}:{secs:02}"
+        return str(seconds)
+    
+    template.globals['format_duration'] = format_duration_func
+
+    html_content = template.render(
+        report_title=report_title,
+        summary=summary,
+        all_results=all_results,
+    )
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(html_content)

robo_automation_test_kit/utils/reports/__init__.py

@@ -0,0 +1,3 @@
+"""
+Report utilities for HTML and Email report generation
+"""