test-reporting 3.1.1__tar.gz → 3.2.0__tar.gz

{test_reporting-3.1.1 → test_reporting-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: test-reporting
-Version: 3.1.1
+Version: 3.2.0
 Summary: Multi-project test reporting dashboard — collect results locally or push to S3
 Home-page: https://github.com/amahdy77/test-reporting.git
 Author: Ashfaqur Mahdy
@@ -43,12 +43,22 @@ Multi-project test reporting dashboard. Collects pytest results, publishes to a
 ## How it works
 
 ```
-Project A tests run  ──┐
-Project B tests run  ──┼──► Central store (local or S3) ──► Dashboard (index.html)
-Project C tests run  ──┘
+Project A: pytest → local SQLite → publish → ┐
+Project B: pytest → local SQLite → publish → ┼─► Central store (local/S3) ─► Dashboard
+Project C: pytest → local SQLite → publish → ┘
 ```
 
-Each project publishes its results to a shared location. The dashboard reads from that location and shows all projects together. The HTML files are static — they're deployed once and the data file (`data.json`) is updated after every run.
+**Local (per project):**
+- Tests run and results are saved to a local SQLite database (`test_results.db`)
+- SQLite is a scratchpad for local commands (`stats`, `suites`, `cleanup`)
+- SQLite is **never** pushed to the store
+
+**Central store (shared):**
+- `test-report publish` reads from SQLite and publishes JSON files to the store
+- Store contains: run files, artifacts (screenshots/traces), and `data.json`
+- Dashboard reads from the store and aggregates all projects
+
+The HTML files are static — deployed once. The `data.json` is rebuilt after every publish.
 
 ---
 
@@ -224,8 +234,14 @@ auto_publish = false
 # Local SQLite — used by stats/suites/cleanup commands
 db_path = test_results.db
 retention_days = 365
+
+# Dashboard data retention (affects data.json size and loading speed)
+dashboard_max_days = 90           # Days of history in dashboard (default: 90)
+dashboard_max_runs_per_suite = 50 # Run history per suite (default: 50)
 ```
 
+**Note:** `retention_days` controls manual cleanup commands, while `dashboard_max_days` and `dashboard_max_runs_per_suite` control what appears in the dashboard automatically. Individual run files remain accessible regardless of these settings.
+
 ---
 
 ## CLI commands
@@ -238,6 +254,49 @@ retention_days = 365
 | `test-report stats` | Show stats from latest run (reads local SQLite) |
 | `test-report suites` | Show suite statistics (reads local SQLite) |
 | `test-report cleanup` | Delete old runs from local SQLite |
+| `test-report cleanup-artifacts` | Delete old screenshots and traces (preserves data) |
+
+### Cleaning up old data
+
+Both cleanup commands use the `retention_days` setting from `reporting.ini` (default: 365 days).
+
+#### `test-report cleanup`
+Removes **all test data** from the **local SQLite database only**:
+- Deletes test runs, results, steps, logs, and analytics older than `retention_days`
+- Use this to free up local database space
+- **Does not affect the published store** (JSON files, artifacts, or dashboard data remain intact)
+- Only impacts local commands like `stats` and `suites`
+
+#### `test-report cleanup-artifacts`
+Removes **only screenshots and traces** while preserving all test data:
+
+```bash
+test-report cleanup-artifacts
+```
+
+This will:
+- Remove screenshots (`.png`) and traces (`.zip`) older than `retention_days`
+- Clean **local** directories (`screenshots/`, `traces/`)
+- Clean **published store** artifacts (`store_path/artifacts/` for local stores)
+- Show file count and total size before deletion
+- Ask for confirmation
+- **Preserve all local SQLite data and published JSON files** (logs, error messages, analytics remain intact)
+
+**Why use this?** Traces can be 10-50 MB each. This frees disk space on both local machines and the published store while keeping all test data for trend analysis.
+
+**What happens in the UI?** The dashboard gracefully handles missing artifacts:
+- Screenshots show: "Screenshot cleaned up" (dashed border placeholder)
+- Trace links show: "Trace file cleaned up" (yellow badge)
+- All test data, logs, and error messages remain visible
+
+**Note:** Only failed tests have screenshots and traces saved. Passed tests don't generate these artifacts.
+
+**S3 limitation:** Currently only cleans local artifacts. S3 artifact cleanup will be added in a future version.
+
+Configure retention in `reporting.ini`:
+```ini
+retention_days = 90  # Keep 90 days of artifacts and data
+```
 
 ---
 

{test_reporting-3.1.1 → test_reporting-3.2.0}/README.md

@@ -7,12 +7,22 @@ Multi-project test reporting dashboard. Collects pytest results, publishes to a
 ## How it works
 
 ```
-Project A tests run  ──┐
-Project B tests run  ──┼──► Central store (local or S3) ──► Dashboard (index.html)
-Project C tests run  ──┘
+Project A: pytest → local SQLite → publish → ┐
+Project B: pytest → local SQLite → publish → ┼─► Central store (local/S3) ─► Dashboard
+Project C: pytest → local SQLite → publish → ┘
 ```
 
-Each project publishes its results to a shared location. The dashboard reads from that location and shows all projects together. The HTML files are static — they're deployed once and the data file (`data.json`) is updated after every run.
+**Local (per project):**
+- Tests run and results are saved to a local SQLite database (`test_results.db`)
+- SQLite is a scratchpad for local commands (`stats`, `suites`, `cleanup`)
+- SQLite is **never** pushed to the store
+
+**Central store (shared):**
+- `test-report publish` reads from SQLite and publishes JSON files to the store
+- Store contains: run files, artifacts (screenshots/traces), and `data.json`
+- Dashboard reads from the store and aggregates all projects
+
+The HTML files are static — deployed once. The `data.json` is rebuilt after every publish.
 
 ---
 
@@ -188,8 +198,14 @@ auto_publish = false
 # Local SQLite — used by stats/suites/cleanup commands
 db_path = test_results.db
 retention_days = 365
+
+# Dashboard data retention (affects data.json size and loading speed)
+dashboard_max_days = 90           # Days of history in dashboard (default: 90)
+dashboard_max_runs_per_suite = 50 # Run history per suite (default: 50)
 ```
 
+**Note:** `retention_days` controls manual cleanup commands, while `dashboard_max_days` and `dashboard_max_runs_per_suite` control what appears in the dashboard automatically. Individual run files remain accessible regardless of these settings.
+
 ---
 
 ## CLI commands
@@ -202,6 +218,49 @@ retention_days = 365
 | `test-report stats` | Show stats from latest run (reads local SQLite) |
 | `test-report suites` | Show suite statistics (reads local SQLite) |
 | `test-report cleanup` | Delete old runs from local SQLite |
+| `test-report cleanup-artifacts` | Delete old screenshots and traces (preserves data) |
+
+### Cleaning up old data
+
+Both cleanup commands use the `retention_days` setting from `reporting.ini` (default: 365 days).
+
+#### `test-report cleanup`
+Removes **all test data** from the **local SQLite database only**:
+- Deletes test runs, results, steps, logs, and analytics older than `retention_days`
+- Use this to free up local database space
+- **Does not affect the published store** (JSON files, artifacts, or dashboard data remain intact)
+- Only impacts local commands like `stats` and `suites`
+
+#### `test-report cleanup-artifacts`
+Removes **only screenshots and traces** while preserving all test data:
+
+```bash
+test-report cleanup-artifacts
+```
+
+This will:
+- Remove screenshots (`.png`) and traces (`.zip`) older than `retention_days`
+- Clean **local** directories (`screenshots/`, `traces/`)
+- Clean **published store** artifacts (`store_path/artifacts/` for local stores)
+- Show file count and total size before deletion
+- Ask for confirmation
+- **Preserve all local SQLite data and published JSON files** (logs, error messages, analytics remain intact)
+
+**Why use this?** Traces can be 10-50 MB each. This frees disk space on both local machines and the published store while keeping all test data for trend analysis.
+
+**What happens in the UI?** The dashboard gracefully handles missing artifacts:
+- Screenshots show: "Screenshot cleaned up" (dashed border placeholder)
+- Trace links show: "Trace file cleaned up" (yellow badge)
+- All test data, logs, and error messages remain visible
+
+**Note:** Only failed tests have screenshots and traces saved. Passed tests don't generate these artifacts.
+
+**S3 limitation:** Currently only cleans local artifacts. S3 artifact cleanup will be added in a future version.
+
+Configure retention in `reporting.ini`:
+```ini
+retention_days = 90  # Keep 90 days of artifacts and data
+```
 
 ---
 

{test_reporting-3.1.1 → test_reporting-3.2.0}/reporting/cli.py

@@ -197,6 +197,28 @@ def show_suites():
     print("\n" + "="*80)
 
 
+def rebuild_dashboard(config_file='reporting.ini'):
+    """Rebuild data.json from existing run files in the store."""
+    config = ReportingConfig(config_file=config_file)
+    publisher = Publisher(config=config)
+    
+    store_type = config.STORE_TYPE
+    store_location = config.S3_BUCKET if store_type == 's3' else str(config.STORE_PATH)
+    print(f"[Reporting] Rebuilding dashboard from {store_type}: {store_location}")
+    
+    if store_type == 's3':
+        s3 = publisher._get_s3_client()
+        publisher._rebuild_data_json_s3(s3, config.S3_BUCKET)
+    else:
+        store = config.STORE_PATH
+        if not store.exists():
+            print(f"[Reporting] Store path does not exist: {store}")
+            sys.exit(1)
+        publisher._rebuild_data_json_local(store)
+    
+    print(f"[Reporting] Dashboard rebuilt successfully!")
+
+
 def cleanup_old_data():
     """Clean up old test data based on retention policy."""
     import sqlite3
@@ -233,15 +255,96 @@ def cleanup_old_data():
     print(f"[Reporting] Remaining: {after_count} test runs")
 
 
+def cleanup_artifacts():
+    """Clean up old screenshots and traces while keeping database records."""
+    import os
+    from datetime import datetime, timedelta
+
+    config = ReportingConfig()
+    
+    print(f"\n[Reporting] Artifact Cleanup")
+    print("=" * 60)
+    print(f"This will delete screenshots and traces older than {config.RETENTION_DAYS} days.")
+    print("Database records and logs will be preserved.")
+    print(f"\nLocal directories:")
+    print(f"  Screenshots: {config.SCREENSHOTS_DIR}")
+    print(f"  Traces:      {config.TRACES_DIR}")
+    
+    # Count files to delete
+    cutoff_date = datetime.now() - timedelta(days=config.RETENTION_DAYS)
+    
+    screenshots_to_delete = []
+    traces_to_delete = []
+    
+    if config.SCREENSHOTS_DIR.exists():
+        for file in config.SCREENSHOTS_DIR.glob('*.png'):
+            if datetime.fromtimestamp(file.stat().st_mtime) < cutoff_date:
+                screenshots_to_delete.append(file)
+    
+    if config.TRACES_DIR.exists():
+        for file in config.TRACES_DIR.glob('*.zip'):
+            if datetime.fromtimestamp(file.stat().st_mtime) < cutoff_date:
+                traces_to_delete.append(file)
+    
+    # Also clean up published artifacts in store
+    store_artifacts = []
+    if config.STORE_TYPE == 'local' and config.STORE_PATH.exists():
+        artifacts_dir = config.STORE_PATH / 'artifacts'
+        if artifacts_dir.exists():
+            print(f"  Store:       {artifacts_dir}")
+            for file in artifacts_dir.glob('*'):
+                if file.suffix in ['.png', '.zip']:
+                    if datetime.fromtimestamp(file.stat().st_mtime) < cutoff_date:
+                        store_artifacts.append(file)
+    
+    total_files = len(screenshots_to_delete) + len(traces_to_delete) + len(store_artifacts)
+    
+    if total_files == 0:
+        print(f"\n[Reporting] No artifacts older than {config.RETENTION_DAYS} days found.")
+        return
+    
+    # Calculate total size
+    total_size = sum(f.stat().st_size for f in screenshots_to_delete + traces_to_delete + store_artifacts)
+    size_mb = total_size / (1024 * 1024)
+    
+    print(f"\nFound artifacts to delete:")
+    print(f"  Local screenshots: {len(screenshots_to_delete)}")
+    print(f"  Local traces:      {len(traces_to_delete)}")
+    if store_artifacts:
+        print(f"  Store artifacts:   {len(store_artifacts)}")
+    print(f"  Total size:        {size_mb:.2f} MB")
+    print(f"\nOlder than: {cutoff_date.strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    response = input(f"\n[Reporting] Delete {total_files} artifact files? (yes/no): ")
+    if response.lower() not in ['yes', 'y']:
+        print("[Reporting] Cleanup cancelled.")
+        return
+    
+    # Delete files
+    deleted_count = 0
+    for file in screenshots_to_delete + traces_to_delete + store_artifacts:
+        try:
+            file.unlink()
+            deleted_count += 1
+        except Exception as e:
+            print(f"[Warning] Could not delete {file.name}: {e}")
+    
+    print(f"\n[Reporting] Cleanup complete!")
+    print(f"Deleted {deleted_count} artifact files ({size_mb:.2f} MB freed)")
+    print(f"Database records preserved for historical analysis.")
+
+
 def main():
     """Main CLI entry point."""
     commands = {
         'publish': (publish, 'Push latest test run to the configured store'),
         'deploy':  (deploy,  'Deploy static dashboard HTML to the store (run once)'),
+        'rebuild': (rebuild_dashboard, 'Rebuild data.json from existing run files'),
         'open':    (open_dashboard, 'Open local dashboard in browser'),
         'stats':   (show_stats,     'Show quick stats from latest run'),
         'suites':  (show_suites,    'Show statistics for all test suites'),
         'cleanup': (cleanup_old_data, 'Clean up old data from local SQLite'),
+        'cleanup-artifacts': (cleanup_artifacts, 'Clean up old screenshots and traces'),
     }
 
     if len(sys.argv) < 2 or sys.argv[1] not in commands:
@@ -271,7 +374,7 @@ def main():
     command_func = commands[command_name][0]
     
     # Only pass config_file to commands that support it
-    if command_name in ['publish', 'deploy']:
+    if command_name in ['publish', 'deploy', 'rebuild']:
         command_func(config_file=config_file)
     else:
         command_func()

{test_reporting-3.1.1 → test_reporting-3.2.0}/reporting/config.py

@@ -33,6 +33,10 @@ class ReportingConfig:
         self.LATEST_JSON_PATH = self.REPORTS_DIR / 'latest.json'
         self.DASHBOARD_DIR = Path(s.get('dashboard_dir', 'dashboard'))
         self.RETENTION_DAYS = int(s.get('retention_days', 365))
+        
+        # Dashboard data retention (affects data.json size and performance)
+        self.DASHBOARD_MAX_DAYS = int(s.get('dashboard_max_days', 90))
+        self.DASHBOARD_MAX_RUNS_PER_SUITE = int(s.get('dashboard_max_runs_per_suite', 50))
 
         # Store config
         self.STORE_TYPE = s.get('store_type', 'local')        # local | s3
@@ -62,6 +66,10 @@ class ReportingConfig:
         self.DB_PATH = Path('test_results.db')
         self.LATEST_JSON_PATH = self.REPORTS_DIR / 'latest.json'
         self.RETENTION_DAYS = 365
+        
+        # Dashboard data retention
+        self.DASHBOARD_MAX_DAYS = 90
+        self.DASHBOARD_MAX_RUNS_PER_SUITE = 50
 
         self.STORE_TYPE = os.getenv('STORE_TYPE', 'local')
         self.STORE_PATH = Path(os.getenv('STORE_PATH', 'dashboard'))

{test_reporting-3.1.1 → test_reporting-3.2.0}/reporting/publisher.py

@@ -12,10 +12,6 @@ from collections import defaultdict
 from .config import ReportingConfig
 
 
-# How many run summaries to keep per suite in data.json
-MAX_RUNS_PER_SUITE = 50
-# How many days of run history to keep in data.json
-MAX_DAYS = 90
 # Minimum runs before flagging a test as flaky
 MIN_RUNS_FOR_FLAKY = 3
 # Minimum avg duration (seconds) to appear in slowest tests
@@ -514,7 +510,7 @@ class Publisher:
             # Trim suite run lists
             for s in suites.values():
                 s['runs'] = sorted(s['runs'], key=lambda r: r['timestamp'], reverse=True)
-                s['runs'] = s['runs'][:MAX_RUNS_PER_SUITE]
+                s['runs'] = s['runs'][:self.config.DASHBOARD_MAX_RUNS_PER_SUITE]
 
             # Sort regressions newest first
             regressions = dict(sorted(regressions.items(), key=lambda x: x[0], reverse=True))
@@ -772,5 +768,5 @@ class Publisher:
     # ------------------------------------------------------------------
 
     def _cutoff_date(self) -> str:
-        cutoff = datetime.now(timezone.utc) - timedelta(days=MAX_DAYS)
+        cutoff = datetime.now(timezone.utc) - timedelta(days=self.config.DASHBOARD_MAX_DAYS)
         return cutoff.isoformat()