pingera-cli 0.1.0__py3-none-any.whl

pingera_cli/formatters/base_formatter.py

@@ -0,0 +1,45 @@
+
+"""
+Base formatter class for check results
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+
+class BaseFormatter(ABC):
+    """Base class for all result formatters"""
+    
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+    
+    @abstractmethod
+    def can_format(self, metadata: Dict[str, Any]) -> bool:
+        """Check if this formatter can handle the given metadata"""
+        pass
+    
+    @abstractmethod
+    def format(self, metadata: Dict[str, Any]) -> str:
+        """Format the metadata into a rich string"""
+        pass
+    
+    def _truncate_text(self, text: str, max_length: int = 100) -> str:
+        """Truncate text if it's too long"""
+        if len(text) > max_length:
+            return text[:max_length] + "..."
+        return text
+    
+    def _format_size(self, size_bytes: int) -> str:
+        """Format size in bytes to human readable format"""
+        if size_bytes > 1024*1024:
+            return f"{size_bytes/(1024*1024):.1f}MB"
+        elif size_bytes > 1024:
+            return f"{size_bytes/1024:.1f}KB"
+        elif size_bytes > 0:
+            return f"{size_bytes}B"
+        else:
+            return "0B"
+    
+    def _format_duration(self, duration_ms: float) -> str:
+        """Format duration in milliseconds"""
+        return f"{duration_ms:.0f}ms" if duration_ms > 0 else "0ms"

pingera_cli/formatters/generic_formatter.py

@@ -0,0 +1,51 @@
+
+"""
+Generic check result formatter for unknown types
+"""
+
+from typing import Dict, Any
+from .base_formatter import BaseFormatter
+
+
+class GenericFormatter(BaseFormatter):
+    """Formatter for generic/unknown check results"""
+    
+    def can_format(self, metadata: Dict[str, Any]) -> bool:
+        """Generic formatter can handle any metadata"""
+        return True
+    
+    def format(self, metadata: Dict[str, Any]) -> str:
+        """Format generic metadata"""
+        info = "\n[bold cyan]Check Metadata:[/bold cyan]"
+        
+        # Display all metadata in a structured way
+        for key, value in metadata.items():
+            if isinstance(value, dict):
+                info += f"\n• {key.replace('_', ' ').title()}:"
+                info += self._format_dict_value(value)
+            elif isinstance(value, list):
+                info += f"\n• {key.replace('_', ' ').title()}: [white]{len(value)} items[/white]"
+                info += self._format_list_value(value)
+            else:
+                display_value = self._truncate_text(str(value))
+                info += f"\n• {key.replace('_', ' ').title()}: [white]{display_value}[/white]"
+        
+        return info
+    
+    def _format_dict_value(self, value: Dict[str, Any]) -> str:
+        """Format dictionary values"""
+        info = ""
+        for sub_key, sub_value in value.items():
+            if isinstance(sub_value, (str, int, float, bool)):
+                info += f"\n  - {sub_key}: [white]{sub_value}[/white]"
+        return info
+    
+    def _format_list_value(self, value: list) -> str:
+        """Format list values"""
+        info = ""
+        # Show first few items
+        for item in value[:3]:
+            if isinstance(item, str):
+                display_item = self._truncate_text(item, 50)
+                info += f"\n  - [dim]{display_item}[/dim]"
+        return info

pingera_cli/formatters/multistep_formatter.py

@@ -0,0 +1,141 @@
+
+"""
+Multistep check result formatter
+"""
+
+from typing import Dict, Any, List
+from .base_formatter import BaseFormatter
+
+
+class MultistepFormatter(BaseFormatter):
+    """Formatter for multistep check results"""
+    
+    def can_format(self, metadata: Dict[str, Any]) -> bool:
+        """Check if this is multistep metadata"""
+        return 'test_results' in metadata and 'test_summary' in metadata
+    
+    def format(self, metadata: Dict[str, Any]) -> str:
+        """Format multistep check metadata"""
+        info = "\n[bold cyan]Multistep Check Results:[/bold cyan]"
+        
+        # Execution time
+        if 'execution_time' in metadata:
+            info += f"\n• Total Execution Time: [yellow]{metadata['execution_time']}ms[/yellow]"
+        
+        # Test Summary
+        if 'test_summary' in metadata:
+            info += self._format_test_summary(metadata['test_summary'])
+        
+        # Test Results
+        if 'test_results' in metadata and metadata['test_results']:
+            info += self._format_test_results(metadata['test_results'])
+        
+        # Location info
+        if 'region' in metadata:
+            info += f"\n• Region: [white]{metadata['region']}[/white]"
+        if 'provider' in metadata:
+            info += f"\n• Provider: [white]{metadata['provider']}[/white]"
+        
+        # Logs
+        if 'logs' in metadata and metadata['logs']:
+            info += self._format_logs(metadata['logs'])
+        
+        return info
+    
+    def _format_test_summary(self, summary: Dict[str, Any]) -> str:
+        """Format test summary"""
+        total = summary.get('total', 0)
+        passed = summary.get('passed', 0)
+        failed = summary.get('failed', 0)
+        duration = summary.get('duration', 0)
+        
+        info = f"\n\n[bold cyan]Test Summary:[/bold cyan]"
+        info += f"\n• Tests: [green]{passed} passed[/green], [red]{failed} failed[/red], [white]{total} total[/white]"
+        info += f"\n• Duration: [yellow]{duration}ms[/yellow]"
+        
+        return info
+    
+    def _format_test_results(self, test_results: List[Dict[str, Any]]) -> str:
+        """Format test results"""
+        info = "\n\n[bold cyan]Test Results:[/bold cyan]"
+        
+        for i, test in enumerate(test_results, 1):
+            status_color = "green" if test.get('status') == 'passed' else "red"
+            status_icon = "✅" if test.get('status') == 'passed' else "❌"
+            test_name = test.get('name', f'Test {i}')
+            duration = test.get('duration', 0)
+            
+            info += f"\n• {test_name}: [{status_color}]{status_icon} {test.get('status', 'unknown')}[/{status_color}]"
+            info += f" ([yellow]{duration}ms[/yellow])"
+            
+            # Soft assertion errors
+            if test.get('softAssertionErrors', 0) > 0:
+                info += f" [yellow]⚠️ {test['softAssertionErrors']} soft assertion errors[/yellow]"
+            
+            # Error details
+            if test.get('error'):
+                error_text = self._truncate_text(test['error'], 80) if not self.verbose else test['error']
+                info += f"\n  [red]Error: {error_text}[/red]"
+            
+            # Steps
+            if 'steps' in test and test['steps']:
+                info += self._format_test_steps(test['steps'])
+        
+        return info
+    
+    def _format_test_steps(self, steps: List[Dict[str, Any]]) -> str:
+        """Format test steps"""
+        info = f"\n  [bold dim]Steps:[/bold dim]"
+        
+        for i, step in enumerate(steps, 1):
+            status_color = "green" if step.get('status') == 'passed' else "red"
+            status_icon = "✓" if step.get('status') == 'passed' else "✗"
+            step_name = step.get('name', f'Step {i}')
+            duration = step.get('duration', 0)
+            
+            info += f"\n    {i}. {step_name}: [{status_color}]{status_icon}[/{status_color}] ([dim]{duration}ms[/dim])"
+            
+            # Step error
+            if step.get('error') and (self.verbose or step.get('status') == 'failed'):
+                error_text = self._truncate_text(step['error'], 60) if not self.verbose else step['error']
+                info += f"\n       [red]Error: {error_text}[/red]"
+        
+        return info
+    
+    def _format_logs(self, logs: List[Dict[str, Any]]) -> str:
+        """Format execution logs"""
+        info = "\n\n[bold cyan]Execution Logs:[/bold cyan]"
+        
+        if not self.verbose:
+            info += f"\n• [dim]Found {len(logs)} log entries (use --verbose to see all)[/dim]"
+            # Show only first few logs in non-verbose mode
+            for log in logs[:3]:
+                level = log.get('level', 'log')
+                message = self._truncate_text(log.get('message', ''), 60)
+                timestamp = log.get('timestamp', '')
+                
+                level_color = self._get_log_level_color(level)
+                info += f"\n• [{level_color}]{level.upper()}[/{level_color}]: [dim]{message}[/dim]"
+        else:
+            # Show all logs in verbose mode
+            for i, log in enumerate(logs, 1):
+                level = log.get('level', 'log')
+                message = log.get('message', '')
+                timestamp = log.get('timestamp', '')
+                
+                level_color = self._get_log_level_color(level)
+                info += f"\n• [{level_color}]{level.upper()}[/{level_color}] [{timestamp}]: {message}"
+        
+        return info
+    
+    def _get_log_level_color(self, level: str) -> str:
+        """Get color for log level"""
+        colors = {
+            'error': 'red',
+            'warn': 'yellow',
+            'warning': 'yellow',
+            'info': 'blue',
+            'log': 'white',
+            'debug': 'dim'
+        }
+        return colors.get(level.lower(), 'white')

pingera_cli/formatters/registry.py

@@ -0,0 +1,35 @@
+
+"""
+Formatter registry for managing different check result formatters
+"""
+
+from typing import Dict, Any, List
+from .base_formatter import BaseFormatter
+from .ssl_formatter import SSLFormatter
+from .synthetic_formatter import SyntheticFormatter
+from .multistep_formatter import MultistepFormatter
+from .web_formatter import WebFormatter
+from .generic_formatter import GenericFormatter
+
+
+class FormatterRegistry:
+    """Registry for managing check result formatters"""
+    
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.formatters: List[BaseFormatter] = [
+            SSLFormatter(verbose),
+            SyntheticFormatter(verbose),
+            MultistepFormatter(verbose),
+            WebFormatter(verbose),
+            GenericFormatter(verbose)  # Generic formatter should be last
+        ]
+    
+    def format_metadata(self, metadata: Dict[str, Any]) -> str:
+        """Format metadata using the appropriate formatter"""
+        for formatter in self.formatters:
+            if formatter.can_format(metadata):
+                return formatter.format(metadata)
+        
+        # This should never happen since GenericFormatter can handle anything
+        return "\n[bold cyan]Check Metadata:[/bold cyan]\n• [dim]No formatter available[/dim]"

pingera_cli/formatters/ssl_formatter.py

@@ -0,0 +1,104 @@
+
+"""
+SSL check result formatter
+"""
+
+from typing import Dict, Any
+from .base_formatter import BaseFormatter
+
+
+class SSLFormatter(BaseFormatter):
+    """Formatter for SSL check results"""
+    
+    def can_format(self, metadata: Dict[str, Any]) -> bool:
+        """Check if this is SSL metadata"""
+        return 'ssl_grade' in metadata or ('checks' in metadata and 'certificate_info' in metadata.get('checks', {}))
+    
+    def format(self, metadata: Dict[str, Any]) -> str:
+        """Format SSL check metadata"""
+        info = "\n[bold cyan]SSL Check Results:[/bold cyan]"
+        
+        # SSL Grade and Score
+        if 'ssl_grade' in metadata:
+            grade_color = "green" if metadata['ssl_grade'] in ['A+', 'A'] else "yellow" if metadata['ssl_grade'] in ['B', 'C'] else "red"
+            info += f"\n• SSL Grade: [{grade_color}]{metadata['ssl_grade']}[/{grade_color}]"
+        
+        if 'ssl_score' in metadata:
+            score_color = "green" if metadata['ssl_score'] >= 80 else "yellow" if metadata['ssl_score'] >= 60 else "red"
+            info += f"\n• SSL Score: [{score_color}]{metadata['ssl_score']}/100[/{score_color}]"
+        
+        # Certificate Information
+        if 'checks' in metadata and 'certificate_info' in metadata['checks']:
+            info += self._format_certificate_info(metadata['checks']['certificate_info'])
+        
+        # Protocol Support
+        if 'checks' in metadata and 'protocol_support' in metadata['checks']:
+            info += self._format_protocol_support(metadata['checks']['protocol_support'])
+        
+        # Vulnerabilities
+        if 'checks' in metadata and 'vulnerabilities' in metadata['checks']:
+            info += self._format_vulnerabilities(metadata['checks']['vulnerabilities'])
+        
+        # Assessment Summary
+        if 'deduction_summary' in metadata:
+            info += "\n\n[bold cyan]Assessment Summary:[/bold cyan]"
+            for summary in metadata['deduction_summary']:
+                info += f"\n• [dim]{summary}[/dim]"
+        
+        return info
+    
+    def _format_certificate_info(self, cert: Dict[str, Any]) -> str:
+        """Format certificate information"""
+        info = "\n\n[bold cyan]Certificate Details:[/bold cyan]"
+        
+        if 'subject' in cert:
+            info += f"\n• Subject: [white]{cert['subject']}[/white]"
+        if 'issuer' in cert:
+            info += f"\n• Issuer: [white]{cert['issuer']}[/white]"
+        if 'not_before' in cert and 'not_after' in cert:
+            info += f"\n• Valid From: [white]{cert['not_before']}[/white]"
+            info += f"\n• Valid Until: [white]{cert['not_after']}[/white]"
+        if 'key_size' in cert:
+            info += f"\n• Key Size: [white]{cert['key_size']} bits[/white]"
+        if 'signature_algorithm' in cert:
+            info += f"\n• Signature Algorithm: [white]{cert['signature_algorithm']}[/white]"
+        
+        # Certificate validation checks
+        if 'cert_date_valid' in cert:
+            status = "✅ Valid" if cert['cert_date_valid'] else "❌ Invalid"
+            info += f"\n• Date Valid: {status}"
+        if 'hostname_mismatch' in cert:
+            status = "❌ Mismatch" if cert['hostname_mismatch'] else "✅ Match"
+            info += f"\n• Hostname: {status}"
+        if 'in_trust_store' in cert:
+            status = "✅ Trusted" if cert['in_trust_store'] else "❌ Not Trusted"
+            info += f"\n• Trust Store: {status}"
+        
+        return info
+    
+    def _format_protocol_support(self, protocols: Dict[str, Any]) -> str:
+        """Format protocol support information"""
+        info = "\n\n[bold cyan]Protocol Support:[/bold cyan]"
+        
+        for protocol, details in protocols.items():
+            if details.get('supported'):
+                cipher_count = len(details.get('ciphers', []))
+                info += f"\n• {protocol.upper().replace('_', '.')}: [green]✅ Supported[/green] ({cipher_count} ciphers)"
+            else:
+                info += f"\n• {protocol.upper().replace('_', '.')}: [red]❌ Not Supported[/red]"
+        
+        return info
+    
+    def _format_vulnerabilities(self, vulns: Dict[str, Any]) -> str:
+        """Format vulnerability information"""
+        info = "\n\n[bold cyan]Security Vulnerabilities:[/bold cyan]"
+        
+        for vuln_name, vuln_data in vulns.items():
+            if vuln_data.get('vulnerable'):
+                info += f"\n• {vuln_name.replace('_', ' ').title()}: [red]❌ Vulnerable[/red]"
+                if 'details' in vuln_data:
+                    info += f"\n  [dim]{vuln_data['details']}[/dim]"
+            else:
+                info += f"\n• {vuln_name.replace('_', ' ').title()}: [green]✅ Not Vulnerable[/green]"
+        
+        return info