apmt-reports 0.1.0__py3-none-any.whl

apmt_reports-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: apmt-reports
+Version: 0.1.0
+Summary: A premium, feature-rich, and beautiful automated testing HTML reporter for pytest, python, and playwright.
+License: MIT
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pytest>=7.0.0
+Requires-Dist: jinja2>=3.0.0
+
+# ⚡ pytest-apmt-reporter
+
+`pytest-apmt-reporter` is a premium, feature-rich, and visually stunning automated testing HTML reporter for **Python**, **Pytest**, and **Playwright**. It is designed as a modern, high-fidelity alternative to Allure and Robot Framework, providing responsive layouts, glowing glassmorphic dark-mode dashboards, interactive SVG charts, expandable execution step logs, failure tracebacks, and seamlessly embedded Playwright screenshots.
+
+## ✨ Features
+
+- **🔌 True Plug-and-Play (Auto-Detect):** By hooking directly into standard pytest entry points, the reporter is automatically active the moment you `pip install` it. No configuration changes required!
+- **🌐 100% Offline-First (Self-Contained):** The final report compiles all layout, styles (CSS), logic (JS), and screenshots (base64 encoded PNGs) into a **single, standalone HTML file**. It requires absolutely zero Internet connection or CDNs to load, making it perfect for secure environments or CI/CD artifacts.
+- **🎨 Premium Visual Dashboard:** Designed with premium glassmorphism card layouts, smooth transition animations, sleek dark mode (with a light theme toggle), and neon indicators for passed/failed tests.
+- **📊 Interactive SVG Charts:** Includes clean, responsive circular progress indicators and data distributions drawn directly via SVG and animated with vanilla JS—no heavy charting libraries (like Chart.js) needed.
+- **📸 Auto Playwright Failure screenshots:** If a test case utilizes a Playwright `page` fixture and fails, the reporter **automatically captures and embeds** a failure screenshot inside the report.
+- **📝 Hierarchical Step Logging:** Allows defining nested execution steps using either standard decorators (`@apmt.step`) or context managers (`with apmt.step`), mirroring Allure and Robot Framework.
+- **📎 Multi-format Attachments:** Programmatically attach raw logs, JSON blobs, HTML widgets, and custom screenshots to any step or stage.
+
+---
+
+## 🚀 Installation
+
+You can easily install the reporter directly into your Python virtual environment from your project directory:
+
+```bash
+# Clone the repository and install in editable mode
+pip install -e .
+```
+
+---
+
+## 🛠️ Usage
+
+Once installed, running pytest will automatically enable the reporter and generate a file named `report.html` in your working directory.
+
+### Basic Commands
+
+```bash
+# Run pytest tests and generate the report with default parameters
+pytest
+
+# Specify a custom report name or output directory
+pytest --apmt-html=outputs/custom_dashboard.html
+
+# Provide a custom title for your report dashboard
+pytest --apmt-title="E2E Portal Smoketests"
+```
+
+---
+
+## 📝 Code API Examples
+
+### 1. Step-by-Step Logging
+
+Organize your test cases into nested, readable, and timed blocks:
+
+```python
+import pytest_apmt_reporter as apmt
+
+# Using step decorator
+@apmt.step("Authenticate credentials")
+def login(username, password):
+    ...
+
+def test_user_purchase_flow():
+    # Using step context manager
+    with apmt.step("Initialize customer basket"):
+        basket_id = 9988
+        
+    login("test_user", "password123")
+```
+
+### 2. Attaching Screenshots and Metadata
+
+Enrich your reports with logs, JSON responses, or manual Playwright screenshots:
+
+```python
+import pytest_apmt_reporter as apmt
+
+def test_payment_gateway_api():
+    # Attach plain text logs
+    apmt.attach("Connecting to stripe sandbox...", name="Stripe API Connection")
+    
+    # Attach JSON payload
+    apmt.attach('{"id": "ch_3M4", "status": "succeeded"}', name="Stripe Response", attachment_type=apmt.AttachmentType.JSON)
+    
+def test_dashboard_visual(page):
+    # Capture and attach a playwright page screenshot manually
+    page.goto("https://admin.portal.local")
+    apmt.attach_screenshot(page, name="Dashboard Main Panel")
+```
+
+### 3. Custom Dashboard Environment Stats
+
+Display important execution parameters (like environment, server names, CI build IDs) directly on the metrics header:
+
+```python
+import pytest_apmt_reporter as apmt
+
+def test_initialize():
+    apmt.set_environment_info("Environment", "Staging-US-East")
+    apmt.set_environment_info("Release Version", "v4.12.0-rc2")
+```
+
+---
+
+## 📊 Try the Demo
+
+Run the pre-configured demo test suite in the repository to see all features in action:
+
+```bash
+# Run the demo tests
+pytest demo/test_playwright_demo.py --apmt-html=demo_report.html
+
+# Open the beautiful dashboard!
+# Windows (PowerShell):
+Start-Process demo_report.html
+# macOS/Linux:
+open demo_report.html
+```

apmt_reports-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pytest_apmt_reporter/__init__.py,sha256=SzoHJ_SdwTu8N3HsphCyo5ZUYQOBARwVCISFpnpaCro,6840
+pytest_apmt_reporter/html_generator.py,sha256=fI4cVdhT_e6HObpjTxiAgkzOYzAMtRNLTUIQYcUFiFs,2205
+pytest_apmt_reporter/model.py,sha256=fVmNBuip7FVAZxyh6PVTUFzQ7ROoy8xWE8pNEvk3KFU,3181
+pytest_apmt_reporter/plugin.py,sha256=GXZy8c_sgtSqpXDS4ePeceATWZODhM4MqMMaNdGDXPo,9803
+pytest_apmt_reporter/templates/report_template.html,sha256=Bg0xKp2N_l0m49qneqxWJj_9gWkijbHC-PM4S8RcWSw,53992
+apmt_reports-0.1.0.dist-info/METADATA,sha256=hnXuQtC4-UwKpljZSdk63Pmgcq7ODwlJ5XhRD6xfdIg,5446
+apmt_reports-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+apmt_reports-0.1.0.dist-info/entry_points.txt,sha256=8M4VEahU6KsP_zbqnJ1j8QVMqdalZPfaq6iXq2_vAPw,55
+apmt_reports-0.1.0.dist-info/top_level.txt,sha256=MKaVtKNhefV4B7nXFyZTtpaI_fn1yKvE83TeXwHGNO8,21
+apmt_reports-0.1.0.dist-info/RECORD,,

apmt_reports-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

apmt_reports-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+apmt_reporter = pytest_apmt_reporter.plugin

apmt_reports-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytest_apmt_reporter

pytest_apmt_reporter/__init__.py

@@ -0,0 +1,188 @@
+import base64
+import inspect
+import threading
+from typing import Any, Callable, List, Optional, Union
+import functools
+import time
+
+from .model import TestCase, Step, Attachment, TestStage
+
+# Thread-local state to track active test cases and step hierarchies
+class APMTRuntimeState(threading.local):
+    def __init__(self):
+        self.active_test: Optional[TestCase] = None
+        self.active_stage_name: str = "call"  # "setup", "call", "teardown"
+        self.step_stack: List[Step] = []
+        self.environment: dict = {}
+
+state = APMTRuntimeState()
+
+class AttachmentType:
+    TEXT = "text/plain"
+    HTML = "text/html"
+    JSON = "application/json"
+    PNG = "image/png"
+    JPG = "image/jpeg"
+    SVG = "image/svg+xml"
+
+class StepContext:
+    def __init__(self, name: str):
+        self.name = name
+        self.step: Optional[Step] = None
+
+    def __enter__(self):
+        self.step = Step(name=self.name)
+        if state.step_stack:
+            # Nest within parent step
+            state.step_stack[-1].steps.append(self.step)
+        else:
+            # Add to active test stage
+            if state.active_test:
+                stage = state.active_test.stages[state.active_stage_name]
+                stage.steps.append(self.step)
+                # Also mirror to test flattend steps
+                state.active_test.steps.append(self.step)
+        
+        state.step_stack.append(self.step)
+        return self.step
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if not self.step:
+            return False
+        
+        status = "passed"
+        exception_msg = None
+        tb_str = None
+        
+        if exc_type:
+            status = "failed"
+            exception_msg = f"{exc_type.__name__}: {str(exc_val)}"
+            import traceback
+            tb_str = "".join(traceback.format_exception(exc_type, exc_val, exc_tb))
+            
+        self.step.finish(status=status, exception_message=exception_msg, traceback=tb_str)
+        
+        if state.step_stack and state.step_stack[-1] == self.step:
+            state.step_stack.pop()
+            
+        # Let exceptions bubble up
+        return False
+
+    def __call__(self, func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            with StepContext(self.name):
+                return func(*args, **kwargs)
+        return wrapper
+
+def step(name_or_func: Union[str, Callable]) -> Any:
+    """Decorator or context manager for defining steps.
+    
+    Usage as decorator:
+        @step("Perform login")
+        def login(user, password):
+            ...
+            
+    Usage as context manager:
+        with step("Perform login"):
+            ...
+    """
+    if isinstance(name_or_func, str):
+        return StepContext(name_or_func)
+    else:
+        # Direct decorator without name (use func name)
+        func = name_or_func
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            step_name = func.__name__.replace('_', ' ').capitalize()
+            with StepContext(step_name):
+                return func(*args, **kwargs)
+        return wrapper
+
+def attach(
+    body: Union[str, bytes],
+    name: str = "Attachment",
+    attachment_type: str = AttachmentType.TEXT
+) -> None:
+    """Attach data or files to the current running test case or step.
+    
+    Args:
+        body: String content or binary bytes.
+        name: User-friendly name for the attachment.
+        attachment_type: MIME type of attachment (e.g. image/png, text/plain).
+    """
+    if not state.active_test:
+        return  # No active test running to attach to
+        
+    is_base64 = False
+    content_str = ""
+    
+    # Process content based on type
+    if isinstance(body, bytes):
+        if "image" in attachment_type or attachment_type in (AttachmentType.PNG, AttachmentType.JPG):
+            content_str = base64.b64encode(body).decode('utf-8')
+            is_base64 = True
+        else:
+            try:
+                content_str = body.decode('utf-8')
+            except UnicodeDecodeError:
+                content_str = base64.b64encode(body).decode('utf-8')
+                is_base64 = True
+    else:
+        content_str = str(body)
+        if attachment_type in (AttachmentType.PNG, AttachmentType.JPG):
+            # Already encoded base64 string
+            is_base64 = True
+
+    attachment = Attachment(name=name, content=content_str, mime_type=attachment_type, is_base64=is_base64)
+    
+    # Add to active step if any, else active stage, else active test
+    if state.step_stack:
+        state.step_stack[-1].attachments.append(attachment)
+    else:
+        stage = state.active_test.stages[state.active_stage_name]
+        stage.attachments.append(attachment)
+        state.active_test.attachments.append(attachment)
+
+def attach_screenshot(page: Any, name: str = "Screenshot") -> None:
+    """Helper to attach a Playwright screenshot. Works with both Sync and Async pages.
+    
+    Args:
+        page: Playwright Page instance.
+        name: Name of the screenshot attachment.
+    """
+    # Check if page is sync or async
+    screenshot_func = getattr(page, "screenshot", None)
+    if not screenshot_func:
+        return
+        
+    # Check if this is a coroutine function (async page)
+    if inspect.iscoroutinefunction(screenshot_func):
+        # We are inside sync code, so executing async is harder without direct await.
+        # But we can try to get the current running loop or advise using manual attach.
+        # However, many async tests run under pytest-asyncio, so we can run it in a thread/loop if possible,
+        # or grab the existing async context. 
+        # A simpler fallback is to let the user know, or execute it safely:
+        try:
+            import asyncio
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # We are in a running loop, scheduled as a task.
+                # Since we can't block, we can schedule the capture, but the test might finish.
+                # For safety, let's advise capturing bytes and attaching:
+                # apmt.attach(await page.screenshot(), "name", apmt.AttachmentType.PNG)
+                # But let's try to block if we can, or log a warning.
+                pass
+        except Exception:
+            pass
+    else:
+        # Sync Playwright page - easy!
+        try:
+            screenshot_bytes = page.screenshot(type="png")
+            attach(screenshot_bytes, name=name, attachment_type=AttachmentType.PNG)
+        except Exception as e:
+            attach(f"Failed to capture screenshot: {str(e)}", name=f"{name} (Failed Capture)", attachment_type=AttachmentType.TEXT)
+
+def set_environment_info(key: str, value: str) -> None:
+    """Sets a global environment variable to be displayed on the report dashboard."""
+    state.environment[key] = str(value)

pytest_apmt_reporter/html_generator.py

@@ -0,0 +1,62 @@
+import os
+import time
+from jinja2 import Template
+from .model import TestRun
+
+class HTMLGenerator:
+    def __init__(self, test_run: TestRun):
+        self.test_run = test_run
+
+    def format_duration(self, seconds: float) -> str:
+        """Helper to format duration nicely (e.g. '1m 23s' or '450ms')."""
+        if seconds < 1.0:
+            return f"{int(seconds * 1000)}ms"
+        minutes = int(seconds // 60)
+        secs = seconds % 60
+        if minutes > 0:
+            return f"{minutes}m {secs:.2f}s"
+        return f"{secs:.2f}s"
+
+    def format_time(self, timestamp: float) -> str:
+        """Helper to format UNIX timestamps."""
+        if not timestamp:
+            return "N/A"
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp))
+
+    def generate(self, output_path: str):
+        # Resolve absolute path to the HTML template
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        template_path = os.path.join(current_dir, "templates", "report_template.html")
+
+        if not os.path.exists(template_path):
+            raise FileNotFoundError(f"APMT report template file not found at: {template_path}")
+
+        with open(template_path, "r", encoding="utf-8") as f:
+            template_source = f.read()
+
+        # Build rendering context with custom 'hash' filter registered
+        from jinja2 import Environment
+        import hashlib
+
+        def jinja_hash_filter(value):
+            return hashlib.md5(str(value).encode('utf-8')).hexdigest()
+
+        env = Environment()
+        env.filters['hash'] = jinja_hash_filter
+        template = env.from_string(template_source)
+        
+        # Resolve directory for output report
+        output_abs = os.path.abspath(output_path)
+        output_dir = os.path.dirname(output_abs)
+        if output_dir and not os.path.exists(output_dir):
+            os.makedirs(output_dir, exist_ok=True)
+
+        # Render HTML
+        rendered_html = template.render(
+            run=self.test_run,
+            formatter=self,
+            generated_at=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+        )
+
+        with open(output_abs, "w", encoding="utf-8") as f:
+            f.write(rendered_html)

pytest_apmt_reporter/model.py

@@ -0,0 +1,91 @@
+import time
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+
+@dataclass
+class Attachment:
+    name: str
+    content: str  # Base64 string for images/binary, plain text for logs
+    mime_type: str
+    is_base64: bool = True
+
+@dataclass
+class Step:
+    name: str
+    status: str = "passed"  # "passed", "failed", "skipped"
+    start_time: float = field(default_factory=time.time)
+    end_time: float = 0.0
+    duration: float = 0.0
+    steps: List['Step'] = field(default_factory=list)
+    attachments: List[Attachment] = field(default_factory=list)
+    exception_message: Optional[str] = None
+    traceback: Optional[str] = None
+
+    def finish(self, status: str = "passed", exception_message: Optional[str] = None, traceback: Optional[str] = None):
+        self.end_time = time.time()
+        self.duration = max(0.0, self.end_time - self.start_time)
+        self.status = status
+        self.exception_message = exception_message
+        self.traceback = traceback
+
+@dataclass
+class TestStage:
+    name: str  # "setup", "call", "teardown"
+    status: str = "passed"
+    duration: float = 0.0
+    stdout: str = ""
+    stderr: str = ""
+    traceback: Optional[str] = None
+    exception_message: Optional[str] = None
+    steps: List[Step] = field(default_factory=list)
+    attachments: List[Attachment] = field(default_factory=list)
+
+@dataclass
+class TestCase:
+    nodeid: str
+    name: str
+    file_path: str
+    line_number: int
+    docstring: Optional[str] = None
+    status: str = "passed"  # "passed", "failed", "skipped", "error"
+    duration: float = 0.0
+    start_time: float = field(default_factory=time.time)
+    end_time: float = 0.0
+    stages: Dict[str, TestStage] = field(default_factory=lambda: {
+        "setup": TestStage("setup"),
+        "call": TestStage("call"),
+        "teardown": TestStage("teardown")
+    })
+    # Flattend aggregated attributes for convenience
+    steps: List[Step] = field(default_factory=list)
+    attachments: List[Attachment] = field(default_factory=list)
+    traceback: Optional[str] = None
+    exception_message: Optional[str] = None
+
+    def finish(self, status: str):
+        self.end_time = time.time()
+        self.duration = max(0.0, self.end_time - self.start_time)
+        self.status = status
+
+@dataclass
+class TestRun:
+    title: str = "APMT Test Automation Report"
+    start_time: float = field(default_factory=time.time)
+    end_time: float = 0.0
+    duration: float = 0.0
+    passed: int = 0
+    failed: int = 0
+    skipped: int = 0
+    error: int = 0
+    total: int = 0
+    test_cases: List[TestCase] = field(default_factory=list)
+    environment: Dict[str, str] = field(default_factory=dict)
+    
+    def finish(self):
+        self.end_time = time.time()
+        self.duration = max(0.0, self.end_time - self.start_time)
+        self.total = len(self.test_cases)
+        self.passed = sum(1 for tc in self.test_cases if tc.status == "passed")
+        self.failed = sum(1 for tc in self.test_cases if tc.status == "failed")
+        self.skipped = sum(1 for tc in self.test_cases if tc.status == "skipped")
+        self.error = sum(1 for tc in self.test_cases if tc.status == "error")