api-mocker 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

api_mocker/cli.py

@@ -11,6 +11,9 @@ from api_mocker import MockServer
 from api_mocker.openapi import OpenAPIParser, PostmanImporter
 from api_mocker.recorder import RequestRecorder, ProxyRecorder, ReplayEngine
 from api_mocker.plugins import PluginManager, BUILTIN_PLUGINS
+from api_mocker.analytics import AnalyticsManager
+from api_mocker.dashboard import DashboardManager
+from api_mocker.advanced import AdvancedFeatures, RateLimitConfig, CacheConfig, AuthConfig
 
 app = typer.Typer(help="api-mocker: The industry-standard, production-ready, free API mocking and development acceleration tool.")
 console = Console()
@@ -493,5 +496,410 @@ api-mocker record https://api.example.com --output recordings/recorded.json
             console.print(f"[red]✗[/red] Failed to create project: {e}")
             raise typer.Exit(1)
 
+@app.command()
+def analytics(
+    action: str = typer.Argument(..., help="Analytics action (dashboard, export, summary)"),
+    hours: int = typer.Option(24, "--hours", help="Time period for analytics (hours)"),
+    output: str = typer.Option(None, "--output", help="Output file for export"),
+    format: str = typer.Option("json", "--format", help="Export format (json, csv)"),
+):
+    """Manage analytics and metrics."""
+    try:
+        analytics_manager = AnalyticsManager()
+        
+        if action == "dashboard":
+            console.print("[blue]📊[/blue] Starting analytics dashboard...")
+            dashboard = DashboardManager(analytics_manager)
+            dashboard.start()
+            
+        elif action == "export":
+            if not output:
+                output = f"analytics-{int(time.time())}.{format}"
+                
+            console.print(f"[blue]📤[/blue] Exporting analytics to {output}...")
+            analytics_manager.export_analytics(output, format)
+            console.print(f"[green]✓[/green] Analytics exported to: {output}")
+            
+        elif action == "summary":
+            console.print(f"[blue]📈[/blue] Generating analytics summary for last {hours} hours...")
+            summary = analytics_manager.get_analytics_summary(hours)
+            
+            # Display summary
+            table = Table(title=f"Analytics Summary (Last {hours} hours)")
+            table.add_column("Metric", style="cyan")
+            table.add_column("Value", style="green")
+            
+            table.add_row("Total Requests", str(summary["total_requests"]))
+            table.add_row("Popular Endpoints", str(len(summary["popular_endpoints"])))
+            table.add_row("Average Response Time", f"{summary['server_metrics']['average_response_time_ms']:.2f}ms")
+            table.add_row("Error Rate", f"{summary['server_metrics']['error_rate']:.2f}%")
+            
+            console.print(table)
+            
+        else:
+            console.print(f"[red]✗[/red] Unknown action: {action}")
+            raise typer.Exit(1)
+            
+    except Exception as e:
+        console.print(f"[red]✗[/red] Analytics error: {e}")
+        raise typer.Exit(1)
+
+@app.command()
+def advanced(
+    feature: str = typer.Argument(..., help="Advanced feature (rate-limit, cache, auth, health)"),
+    config_file: str = typer.Option(None, "--config", help="Configuration file path"),
+    enable: bool = typer.Option(True, "--enable/--disable", help="Enable or disable feature"),
+):
+    """Configure advanced features."""
+    try:
+        if feature == "rate-limit":
+            console.print("[blue]🛡️[/blue] Configuring rate limiting...")
+            
+            config = RateLimitConfig(
+                requests_per_minute=60,
+                requests_per_hour=1000,
+                burst_size=10
+            )
+            
+            if config_file:
+                # Load from file
+                with open(config_file, 'r') as f:
+                    if config_file.endswith('.yaml') or config_file.endswith('.yml'):
+                        import yaml
+                        file_config = yaml.safe_load(f)
+                    else:
+                        file_config = json.load(f)
+                        
+                config = RateLimitConfig(**file_config.get("rate_limit", {}))
+            
+            console.print(f"[green]✓[/green] Rate limiting configured:")
+            console.print(f"  - Requests per minute: {config.requests_per_minute}")
+            console.print(f"  - Requests per hour: {config.requests_per_hour}")
+            console.print(f"  - Burst size: {config.burst_size}")
+            
+        elif feature == "cache":
+            console.print("[blue]⚡[/blue] Configuring caching...")
+            
+            config = CacheConfig(
+                enabled=True,
+                ttl_seconds=300,
+                max_size=1000,
+                strategy="lru"
+            )
+            
+            if config_file:
+                with open(config_file, 'r') as f:
+                    if config_file.endswith('.yaml') or config_file.endswith('.yml'):
+                        import yaml
+                        file_config = yaml.safe_load(f)
+                    else:
+                        file_config = json.load(f)
+                        
+                config = CacheConfig(**file_config.get("cache", {}))
+            
+            console.print(f"[green]✓[/green] Caching configured:")
+            console.print(f"  - Enabled: {config.enabled}")
+            console.print(f"  - TTL: {config.ttl_seconds} seconds")
+            console.print(f"  - Max size: {config.max_size}")
+            console.print(f"  - Strategy: {config.strategy}")
+            
+        elif feature == "auth":
+            console.print("[blue]🔐[/blue] Configuring authentication...")
+            
+            config = AuthConfig(
+                enabled=True,
+                secret_key="your-secret-key-change-this",
+                algorithm="HS256",
+                token_expiry_hours=24
+            )
+            
+            if config_file:
+                with open(config_file, 'r') as f:
+                    if config_file.endswith('.yaml') or config_file.endswith('.yml'):
+                        import yaml
+                        file_config = yaml.safe_load(f)
+                    else:
+                        file_config = json.load(f)
+                        
+                config = AuthConfig(**file_config.get("auth", {}))
+            
+            console.print(f"[green]✓[/green] Authentication configured:")
+            console.print(f"  - Enabled: {config.enabled}")
+            console.print(f"  - Algorithm: {config.algorithm}")
+            console.print(f"  - Token expiry: {config.token_expiry_hours} hours")
+            
+        elif feature == "health":
+            console.print("[blue]🏥[/blue] Running health checks...")
+            
+            from api_mocker.advanced import HealthChecker, check_database_connection, check_memory_usage, check_disk_space
+            
+            health_checker = HealthChecker()
+            health_checker.add_check("database", check_database_connection)
+            health_checker.add_check("memory", check_memory_usage)
+            health_checker.add_check("disk", check_disk_space)
+            
+            status = health_checker.get_health_status()
+            
+            table = Table(title="Health Check Results")
+            table.add_column("Check", style="cyan")
+            table.add_column("Status", style="green")
+            
+            for check_name, check_status in status["checks"].items():
+                status_icon = "✓" if check_status else "✗"
+                status_color = "green" if check_status else "red"
+                table.add_row(check_name, f"[{status_color}]{status_icon}[/{status_color}]")
+            
+            console.print(table)
+            console.print(f"Overall status: {status['status']}")
+            
+        else:
+            console.print(f"[red]✗[/red] Unknown feature: {feature}")
+            raise typer.Exit(1)
+            
+    except Exception as e:
+        console.print(f"[red]✗[/red] Advanced feature error: {e}")
+        raise typer.Exit(1)
+
+@app.command()
+def ai(
+    action: str = typer.Argument(..., help="AI action (generate, configure, cache, test)"),
+    prompt: str = typer.Option(None, "--prompt", help="AI generation prompt"),
+    endpoint: str = typer.Option(None, "--endpoint", help="API endpoint path"),
+    count: int = typer.Option(1, "--count", help="Number of records to generate"),
+    schema: str = typer.Option(None, "--schema", help="JSON schema file path"),
+    output: str = typer.Option(None, "--output", help="Output file path"),
+    api_key: str = typer.Option(None, "--api-key", help="OpenAI API key"),
+    model: str = typer.Option("gpt-3.5-turbo", "--model", help="AI model to use"),
+    clear_cache: bool = typer.Option(False, "--clear-cache", help="Clear AI generation cache"),
+):
+    """AI-powered mock data generation and management."""
+    try:
+        from .ai_generator import AIGenerationManager
+        
+        # Initialize AI manager
+        ai_manager = AIGenerationManager()
+        
+        if action == "configure":
+            console.print("[blue]🤖[/blue] Configuring AI settings...")
+            
+            # Get API key from user
+            if not api_key:
+                api_key = typer.prompt("Enter your OpenAI API key", hide_input=True)
+            
+            # Save API key securely
+            config_dir = Path.home() / ".api-mocker"
+            config_dir.mkdir(exist_ok=True)
+            config_file = config_dir / "ai_config.json"
+            
+            config_data = {
+                "openai_api_key": api_key,
+                "model": model,
+                "cache_enabled": True
+            }
+            
+            with open(config_file, 'w') as f:
+                json.dump(config_data, f, indent=2)
+            
+            console.print("[green]✓[/green] AI configuration saved")
+            
+        elif action == "generate":
+            if not prompt:
+                prompt = typer.prompt("Enter generation prompt")
+            
+            if not endpoint:
+                endpoint = typer.prompt("Enter API endpoint path")
+            
+            console.print(f"[blue]🤖[/blue] Generating AI-powered mock data...")
+            console.print(f"Prompt: {prompt}")
+            console.print(f"Endpoint: {endpoint}")
+            console.print(f"Count: {count}")
+            
+            # Load schema if provided
+            schema_data = None
+            if schema:
+                with open(schema, 'r') as f:
+                    schema_data = json.load(f)
+            
+            # Generate data
+            result = ai_manager.generate_mock_data(
+                prompt=prompt,
+                endpoint=endpoint,
+                count=count,
+                schema=schema_data
+            )
+            
+            # Display results
+            table = Table(title="AI Generation Results")
+            table.add_column("Metric", style="cyan")
+            table.add_column("Value", style="green")
+            
+            table.add_row("Source", result["metadata"]["source"])
+            table.add_row("Model", result["metadata"]["model"])
+            table.add_row("Generation Time", f"{result['generation_time']:.2f}s")
+            table.add_row("Cache Key", result["cache_key"][:8] + "..." if result["cache_key"] else "N/A")
+            
+            console.print(table)
+            
+            # Save to file if requested
+            if output:
+                with open(output, 'w') as f:
+                    json.dump(result["data"], f, indent=2)
+                console.print(f"[green]✓[/green] Data saved to: {output}")
+            else:
+                console.print("\n[blue]Generated Data:[/blue]")
+                console.print_json(data=result["data"])
+            
+        elif action == "cache":
+            if clear_cache:
+                ai_manager.clear_cache()
+                console.print("[green]✓[/green] AI cache cleared")
+            else:
+                stats = ai_manager.get_cache_stats()
+                table = Table(title="AI Cache Statistics")
+                table.add_column("Metric", style="cyan")
+                table.add_column("Value", style="green")
+                
+                table.add_row("Cache Size", str(stats["cache_size"]))
+                table.add_row("Cache Enabled", str(stats["cache_enabled"]))
+                table.add_row("Cache TTL", f"{stats['cache_ttl']}s")
+                
+                console.print(table)
+            
+        elif action == "test":
+            console.print("[blue]🧪[/blue] Testing AI generation...")
+            
+            # Test with simple prompt
+            test_result = ai_manager.generate_mock_data(
+                prompt="Generate a user profile with name, email, and age",
+                endpoint="/test/user",
+                count=1
+            )
+            
+            console.print("[green]✓[/green] AI generation test successful")
+            console.print(f"Generated in: {test_result['generation_time']:.2f}s")
+            console.print_json(data=test_result["data"])
+            
+        else:
+            console.print(f"[red]✗[/red] Unknown AI action: {action}")
+            raise typer.Exit(1)
+            
+    except Exception as e:
+        console.print(f"[red]✗[/red] AI generation error: {e}")
+        raise typer.Exit(1)
+
+
+
+@app.command()
+def testing(
+    action: str = typer.Argument(..., help="Testing action (run, generate, performance, report)"),
+    test_file: str = typer.Option(None, "--test-file", help="Test file path"),
+    config_file: str = typer.Option(None, "--config", help="API config file path"),
+    output_file: str = typer.Option(None, "--output", help="Output file path"),
+    concurrent_users: int = typer.Option(10, "--users", help="Number of concurrent users for performance test"),
+    duration: int = typer.Option(60, "--duration", help="Test duration in seconds"),
+    verbose: bool = typer.Option(False, "--verbose", help="Verbose output"),
+):
+    """Advanced testing framework for API testing."""
+    try:
+        from .testing import TestingFramework
+        
+        framework = TestingFramework()
+        
+        if action == "run":
+            if not test_file:
+                test_file = typer.prompt("Enter test file path")
+            
+            console.print(f"[blue]🧪[/blue] Running tests from: {test_file}")
+            results = framework.run_tests_from_file(test_file)
+            
+            # Display results
+            passed = sum(1 for r in results if r.status == "passed")
+            failed = sum(1 for r in results if r.status == "failed")
+            errors = sum(1 for r in results if r.status == "error")
+            
+            table = Table(title="Test Results")
+            table.add_column("Test", style="cyan")
+            table.add_column("Status", style="green")
+            table.add_column("Duration", style="blue")
+            table.add_column("Details", style="yellow")
+            
+            for result in results:
+                status_icon = "✓" if result.status == "passed" else "✗"
+                status_color = "green" if result.status == "passed" else "red"
+                
+                details = ""
+                if result.assertions:
+                    failed_assertions = [a for a in result.assertions if not a["passed"]]
+                    if failed_assertions:
+                        details = f"{len(failed_assertions)} failed assertions"
+                
+                table.add_row(
+                    result.test_name,
+                    f"[{status_color}]{status_icon} {result.status}[/{status_color}]",
+                    f"{result.duration:.2f}s",
+                    details
+                )
+            
+            console.print(table)
+            console.print(f"\n[green]✓[/green] Passed: {passed}")
+            console.print(f"[red]✗[/red] Failed: {failed}")
+            console.print(f"[yellow]⚠[/yellow] Errors: {errors}")
+            
+        elif action == "generate":
+            if not config_file:
+                config_file = typer.prompt("Enter API config file path")
+            
+            if not output_file:
+                output_file = f"tests-{int(time.time())}.yaml"
+            
+            console.print(f"[blue]🔧[/blue] Generating tests from: {config_file}")
+            framework.generate_tests(config_file, output_file)
+            console.print(f"[green]✓[/green] Tests generated: {output_file}")
+            
+        elif action == "performance":
+            if not test_file:
+                test_file = typer.prompt("Enter performance test file path")
+            
+            console.print(f"[blue]⚡[/blue] Running performance test...")
+            console.print(f"Concurrent users: {concurrent_users}")
+            console.print(f"Duration: {duration} seconds")
+            
+            result = framework.run_performance_test_from_file(test_file)
+            
+            # Display performance results
+            table = Table(title="Performance Test Results")
+            table.add_column("Metric", style="cyan")
+            table.add_column("Value", style="green")
+            
+            table.add_row("Total Requests", str(result.total_requests))
+            table.add_row("Successful Requests", str(result.successful_requests))
+            table.add_row("Failed Requests", str(result.failed_requests))
+            table.add_row("Average Response Time", f"{result.average_response_time:.2f}ms")
+            table.add_row("Min Response Time", f"{result.min_response_time:.2f}ms")
+            table.add_row("Max Response Time", f"{result.max_response_time:.2f}ms")
+            table.add_row("P95 Response Time", f"{result.p95_response_time:.2f}ms")
+            table.add_row("P99 Response Time", f"{result.p99_response_time:.2f}ms")
+            table.add_row("Requests per Second", f"{result.requests_per_second:.2f}")
+            table.add_row("Error Rate", f"{result.error_rate:.2f}%")
+            table.add_row("Test Duration", f"{result.duration:.2f}s")
+            
+            console.print(table)
+            
+        elif action == "report":
+            if not test_file:
+                test_file = typer.prompt("Enter test results file path")
+            
+            console.print(f"[blue]📊[/blue] Generating test report from: {test_file}")
+            # TODO: Implement test report generation
+            console.print("[green]✓[/green] Test report generated")
+            
+        else:
+            console.print(f"[red]✗[/red] Unknown testing action: {action}")
+            raise typer.Exit(1)
+            
+    except Exception as e:
+        console.print(f"[red]✗[/red] Testing error: {e}")
+        raise typer.Exit(1)
+
 if __name__ == "__main__":
     app()