785 lines
28 KiB
Python
785 lines
28 KiB
Python
|
#!/usr/bin/env python3
|
||
|
|
# ================================================================
|
||
|
|
# services/auth/tests/run_tests.py
|
||
|
|
# Complete test runner script for auth service with comprehensive reporting
|
||
|
|
# ================================================================
|
||
|
|
"""
|
||
|
|
Comprehensive test runner for authentication service
|
||
|
|
Provides various test execution modes and detailed reporting
|
||
|
|
"""
|
||
|
|
|
||
|
|
import os
|
||
|
|
import sys
|
||
|
|
import subprocess
|
||
|
|
import argparse
|
||
|
|
import time
|
||
|
|
import json
|
||
|
|
from pathlib import Path
|
||
|
|
from typing import List, Dict, Optional, Tuple
|
||
|
|
from datetime import datetime
|
||
|
|
|
||
|
|
# Add the project root to Python path
|
||
|
|
project_root = Path(__file__).parent.parent.parent.parent
|
||
|
|
sys.path.insert(0, str(project_root))
|
||
|
|
|
||
|
|
class Colors:
|
||
|
|
"""ANSI color codes for terminal output"""
|
||
|
|
RED = '\033[91m'
|
||
|
|
GREEN = '\033[92m'
|
||
|
|
YELLOW = '\033[93m'
|
||
|
|
BLUE = '\033[94m'
|
||
|
|
MAGENTA = '\033[95m'
|
||
|
|
CYAN = '\033[96m'
|
||
|
|
WHITE = '\033[97m'
|
||
|
|
BOLD = '\033[1m'
|
||
|
|
UNDERLINE = '\033[4m'
|
||
|
|
END = '\033[0m'
|
||
|
|
|
||
|
|
@classmethod
|
||
|
|
def colorize(cls, text: str, color: str) -> str:
|
||
|
|
"""Colorize text for terminal output"""
|
||
|
|
return f"{color}{text}{cls.END}"
|
||
|
|
|
||
|
|
class TestMetrics:
|
||
|
|
"""Track test execution metrics"""
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
self.start_time = None
|
||
|
|
self.end_time = None
|
||
|
|
self.tests_run = 0
|
||
|
|
self.tests_passed = 0
|
||
|
|
self.tests_failed = 0
|
||
|
|
self.tests_skipped = 0
|
||
|
|
self.coverage_percentage = 0.0
|
||
|
|
self.warnings_count = 0
|
||
|
|
self.errors = []
|
||
|
|
|
||
|
|
def start(self):
|
||
|
|
"""Start timing"""
|
||
|
|
self.start_time = time.time()
|
||
|
|
|
||
|
|
def stop(self):
|
||
|
|
"""Stop timing"""
|
||
|
|
self.end_time = time.time()
|
||
|
|
|
||
|
|
@property
|
||
|
|
def duration(self) -> float:
|
||
|
|
"""Get duration in seconds"""
|
||
|
|
if self.start_time and self.end_time:
|
||
|
|
return self.end_time - self.start_time
|
||
|
|
return 0.0
|
||
|
|
|
||
|
|
@property
|
||
|
|
def success_rate(self) -> float:
|
||
|
|
"""Get success rate percentage"""
|
||
|
|
if self.tests_run > 0:
|
||
|
|
return (self.tests_passed / self.tests_run) * 100
|
||
|
|
return 0.0
|
||
|
|
|
||
|
|
class AuthTestRunner:
|
||
|
|
"""Test runner for authentication service with enhanced features"""
|
||
|
|
|
||
|
|
def __init__(self, test_dir: str = "tests"):
|
||
|
|
self.test_dir = Path(test_dir)
|
||
|
|
self.project_root = Path(__file__).parent.parent
|
||
|
|
self.results: Dict[str, TestMetrics] = {}
|
||
|
|
self.overall_metrics = TestMetrics()
|
||
|
|
|
||
|
|
def _print_header(self, title: str, char: str = "=", width: int = 80):
|
||
|
|
"""Print a formatted header"""
|
||
|
|
print(Colors.colorize(char * width, Colors.CYAN))
|
||
|
|
centered_title = title.center(width)
|
||
|
|
print(Colors.colorize(centered_title, Colors.BOLD + Colors.WHITE))
|
||
|
|
print(Colors.colorize(char * width, Colors.CYAN))
|
||
|
|
|
||
|
|
def _print_step(self, message: str, emoji: str = "📋"):
|
||
|
|
"""Print a step message"""
|
||
|
|
print(f"\n{emoji} {Colors.colorize(message, Colors.BLUE)}")
|
||
|
|
|
||
|
|
def _print_success(self, message: str):
|
||
|
|
"""Print success message"""
|
||
|
|
print(f"✅ {Colors.colorize(message, Colors.GREEN)}")
|
||
|
|
|
||
|
|
def _print_error(self, message: str):
|
||
|
|
"""Print error message"""
|
||
|
|
print(f"❌ {Colors.colorize(message, Colors.RED)}")
|
||
|
|
|
||
|
|
def _print_warning(self, message: str):
|
||
|
|
"""Print warning message"""
|
||
|
|
print(f"⚠️ {Colors.colorize(message, Colors.YELLOW)}")
|
||
|
|
|
||
|
|
def run_command(self, cmd: List[str], capture_output: bool = True, timeout: int = 300) -> subprocess.CompletedProcess:
|
||
|
|
"""Run a command and return the result"""
|
||
|
|
cmd_str = ' '.join(cmd)
|
||
|
|
print(f"🚀 Running: {Colors.colorize(cmd_str, Colors.MAGENTA)}")
|
||
|
|
|
||
|
|
try:
|
||
|
|
result = subprocess.run(
|
||
|
|
cmd,
|
||
|
|
capture_output=capture_output,
|
||
|
|
text=True,
|
||
|
|
cwd=self.project_root,
|
||
|
|
timeout=timeout
|
||
|
|
)
|
||
|
|
return result
|
||
|
|
except subprocess.TimeoutExpired:
|
||
|
|
self._print_error(f"Test execution timed out ({timeout} seconds)")
|
||
|
|
return subprocess.CompletedProcess(cmd, 1, "", "Timeout")
|
||
|
|
except Exception as e:
|
||
|
|
self._print_error(f"Error running command: {e}")
|
||
|
|
return subprocess.CompletedProcess(cmd, 1, "", str(e))
|
||
|
|
|
||
|
|
def _parse_pytest_output(self, output: str) -> TestMetrics:
|
||
|
|
"""Parse pytest output to extract metrics"""
|
||
|
|
metrics = TestMetrics()
|
||
|
|
|
||
|
|
lines = output.split('\n')
|
||
|
|
for line in lines:
|
||
|
|
line = line.strip()
|
||
|
|
|
||
|
|
# Parse test results line (e.g., "45 passed, 2 failed, 1 skipped in 12.34s")
|
||
|
|
if ' passed' in line or ' failed' in line:
|
||
|
|
parts = line.split()
|
||
|
|
for i, part in enumerate(parts):
|
||
|
|
if part.isdigit():
|
||
|
|
count = int(part)
|
||
|
|
if i + 1 < len(parts):
|
||
|
|
result_type = parts[i + 1]
|
||
|
|
if 'passed' in result_type:
|
||
|
|
metrics.tests_passed = count
|
||
|
|
elif 'failed' in result_type:
|
||
|
|
metrics.tests_failed = count
|
||
|
|
elif 'skipped' in result_type:
|
||
|
|
metrics.tests_skipped = count
|
||
|
|
elif 'warning' in result_type:
|
||
|
|
metrics.warnings_count = count
|
||
|
|
|
||
|
|
# Parse coverage percentage
|
||
|
|
if 'TOTAL' in line and '%' in line:
|
||
|
|
parts = line.split()
|
||
|
|
for part in parts:
|
||
|
|
if '%' in part:
|
||
|
|
try:
|
||
|
|
metrics.coverage_percentage = float(part.replace('%', ''))
|
||
|
|
except ValueError:
|
||
|
|
pass
|
||
|
|
|
||
|
|
metrics.tests_run = metrics.tests_passed + metrics.tests_failed + metrics.tests_skipped
|
||
|
|
return metrics
|
||
|
|
|
||
|
|
def run_all_tests(self, verbose: bool = True) -> bool:
|
||
|
|
"""Run all authentication tests"""
|
||
|
|
self._print_step("Running all authentication tests", "🧪")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"-v" if verbose else "-q",
|
||
|
|
"--tb=short",
|
||
|
|
"--strict-markers",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
|
||
|
|
result = self.run_command(cmd, capture_output=not verbose)
|
||
|
|
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
if not verbose and result.stdout:
|
||
|
|
parsed_metrics = self._parse_pytest_output(result.stdout)
|
||
|
|
metrics.tests_run = parsed_metrics.tests_run
|
||
|
|
metrics.tests_passed = parsed_metrics.tests_passed
|
||
|
|
metrics.tests_failed = parsed_metrics.tests_failed
|
||
|
|
metrics.tests_skipped = parsed_metrics.tests_skipped
|
||
|
|
|
||
|
|
self.results['all_tests'] = metrics
|
||
|
|
|
||
|
|
success = result.returncode == 0
|
||
|
|
if success:
|
||
|
|
self._print_success(f"All tests completed successfully ({metrics.duration:.2f}s)")
|
||
|
|
else:
|
||
|
|
self._print_error(f"Some tests failed ({metrics.duration:.2f}s)")
|
||
|
|
|
||
|
|
return success
|
||
|
|
|
||
|
|
def run_unit_tests(self) -> bool:
|
||
|
|
"""Run unit tests only"""
|
||
|
|
self._print_step("Running unit tests", "🔬")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"-v", "-m", "unit",
|
||
|
|
"--tb=short",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
result = self.run_command(cmd, capture_output=False)
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
self.results['unit_tests'] = metrics
|
||
|
|
return result.returncode == 0
|
||
|
|
|
||
|
|
def run_integration_tests(self) -> bool:
|
||
|
|
"""Run integration tests only"""
|
||
|
|
self._print_step("Running integration tests", "🔗")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"-v", "-m", "integration",
|
||
|
|
"--tb=short",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
result = self.run_command(cmd, capture_output=False)
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
self.results['integration_tests'] = metrics
|
||
|
|
return result.returncode == 0
|
||
|
|
|
||
|
|
def run_api_tests(self) -> bool:
|
||
|
|
"""Run API endpoint tests only"""
|
||
|
|
self._print_step("Running API tests", "🌐")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"-v", "-m", "api",
|
||
|
|
"--tb=short",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
result = self.run_command(cmd, capture_output=False)
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
self.results['api_tests'] = metrics
|
||
|
|
return result.returncode == 0
|
||
|
|
|
||
|
|
def run_security_tests(self) -> bool:
|
||
|
|
"""Run security tests only"""
|
||
|
|
self._print_step("Running security tests", "🔒")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"-v", "-m", "security",
|
||
|
|
"--tb=short",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
result = self.run_command(cmd, capture_output=False)
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
self.results['security_tests'] = metrics
|
||
|
|
return result.returncode == 0
|
||
|
|
|
||
|
|
def run_performance_tests(self) -> bool:
|
||
|
|
"""Run performance tests only"""
|
||
|
|
self._print_step("Running performance tests", "⚡")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"-v", "-m", "performance",
|
||
|
|
"--tb=short",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
result = self.run_command(cmd, capture_output=False)
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
self.results['performance_tests'] = metrics
|
||
|
|
return result.returncode == 0
|
||
|
|
|
||
|
|
def run_coverage_tests(self) -> bool:
|
||
|
|
"""Run tests with coverage reporting"""
|
||
|
|
self._print_step("Running tests with coverage", "📊")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"--cov=app",
|
||
|
|
"--cov-report=html:htmlcov",
|
||
|
|
"--cov-report=term-missing",
|
||
|
|
"--cov-report=xml",
|
||
|
|
"--cov-branch",
|
||
|
|
"-v",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
result = self.run_command(cmd, capture_output=True)
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
if result.stdout:
|
||
|
|
parsed_metrics = self._parse_pytest_output(result.stdout)
|
||
|
|
metrics.coverage_percentage = parsed_metrics.coverage_percentage
|
||
|
|
print(result.stdout)
|
||
|
|
|
||
|
|
self.results['coverage_tests'] = metrics
|
||
|
|
|
||
|
|
if result.returncode == 0:
|
||
|
|
self._print_success("Coverage report generated in htmlcov/index.html")
|
||
|
|
if metrics.coverage_percentage > 0:
|
||
|
|
self._print_success(f"Coverage: {metrics.coverage_percentage:.1f}%")
|
||
|
|
|
||
|
|
return result.returncode == 0
|
||
|
|
|
||
|
|
def run_fast_tests(self) -> bool:
|
||
|
|
"""Run fast tests (exclude slow/performance tests)"""
|
||
|
|
self._print_step("Running fast tests only", "⚡")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"-v", "-m", "not slow",
|
||
|
|
"--tb=short",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
result = self.run_command(cmd, capture_output=False)
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
self.results['fast_tests'] = metrics
|
||
|
|
return result.returncode == 0
|
||
|
|
|
||
|
|
def run_specific_test(self, test_pattern: str) -> bool:
|
||
|
|
"""Run specific test by pattern"""
|
||
|
|
self._print_step(f"Running tests matching: {test_pattern}", "🎯")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"-v", "-k", test_pattern,
|
||
|
|
"--tb=short",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
result = self.run_command(cmd, capture_output=False)
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
self.results[f'specific_test_{test_pattern}'] = metrics
|
||
|
|
return result.returncode == 0
|
||
|
|
|
||
|
|
def run_parallel_tests(self, num_workers: Optional[int] = None) -> bool:
|
||
|
|
"""Run tests in parallel"""
|
||
|
|
if num_workers is None:
|
||
|
|
num_workers_str = "auto"
|
||
|
|
else:
|
||
|
|
num_workers_str = str(num_workers)
|
||
|
|
|
||
|
|
self._print_step(f"Running tests in parallel with {num_workers_str} workers", "🚀")
|
||
|
|
|
||
|
|
cmd = [
|
||
|
|
sys.executable, "-m", "pytest",
|
||
|
|
str(self.test_dir),
|
||
|
|
"-v", "-n", num_workers_str,
|
||
|
|
"--tb=short",
|
||
|
|
"--color=yes"
|
||
|
|
]
|
||
|
|
|
||
|
|
metrics = TestMetrics()
|
||
|
|
metrics.start()
|
||
|
|
result = self.run_command(cmd, capture_output=False)
|
||
|
|
metrics.stop()
|
||
|
|
|
||
|
|
self.results['parallel_tests'] = metrics
|
||
|
|
return result.returncode == 0
|
||
|
|
|
||
|
|
def validate_test_environment(self) -> bool:
|
||
|
|
"""Validate that the test environment is set up correctly"""
|
||
|
|
self._print_step("Validating test environment", "🔍")
|
||
|
|
|
||
|
|
validation_steps = [
|
||
|
|
("Checking pytest availability", self._check_pytest),
|
||
|
|
("Checking test files", self._check_test_files),
|
||
|
|
("Checking app module", self._check_app_module),
|
||
|
|
("Checking database module", self._check_database_module),
|
||
|
|
("Checking dependencies", self._check_dependencies),
|
||
|
|
]
|
||
|
|
|
||
|
|
all_valid = True
|
||
|
|
for step_name, step_func in validation_steps:
|
||
|
|
print(f" 📋 {step_name}...")
|
||
|
|
if step_func():
|
||
|
|
self._print_success(f" {step_name}")
|
||
|
|
else:
|
||
|
|
self._print_error(f" {step_name}")
|
||
|
|
all_valid = False
|
||
|
|
|
||
|
|
return all_valid
|
||
|
|
|
||
|
|
def _check_pytest(self) -> bool:
|
||
|
|
"""Check if pytest is available"""
|
||
|
|
try:
|
||
|
|
result = subprocess.run([sys.executable, "-m", "pytest", "--version"],
|
||
|
|
capture_output=True, text=True)
|
||
|
|
if result.returncode != 0:
|
||
|
|
return False
|
||
|
|
print(f" ✅ {result.stdout.strip()}")
|
||
|
|
return True
|
||
|
|
except Exception:
|
||
|
|
return False
|
||
|
|
|
||
|
|
def _check_test_files(self) -> bool:
|
||
|
|
"""Check if test files exist"""
|
||
|
|
test_files = list(self.test_dir.glob("test_*.py"))
|
||
|
|
if not test_files:
|
||
|
|
print(f" ❌ No test files found in {self.test_dir}")
|
||
|
|
return False
|
||
|
|
print(f" ✅ Found {len(test_files)} test files")
|
||
|
|
return True
|
||
|
|
|
||
|
|
def _check_app_module(self) -> bool:
|
||
|
|
"""Check if app module can be imported"""
|
||
|
|
try:
|
||
|
|
sys.path.insert(0, str(self.project_root))
|
||
|
|
import app
|
||
|
|
print(" ✅ App module can be imported")
|
||
|
|
return True
|
||
|
|
except ImportError as e:
|
||
|
|
print(f" ❌ Cannot import app module: {e}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
def _check_database_module(self) -> bool:
|
||
|
|
"""Check database connectivity"""
|
||
|
|
try:
|
||
|
|
from app.core.database import get_db
|
||
|
|
print(" ✅ Database module available")
|
||
|
|
return True
|
||
|
|
except ImportError as e:
|
||
|
|
print(f" ⚠️ Database module not available: {e}")
|
||
|
|
return True # Non-critical for some tests
|
||
|
|
|
||
|
|
def _check_dependencies(self) -> bool:
|
||
|
|
"""Check required dependencies"""
|
||
|
|
required_packages = [
|
||
|
|
"pytest",
|
||
|
|
"pytest-asyncio",
|
||
|
|
"fastapi",
|
||
|
|
"sqlalchemy",
|
||
|
|
"pydantic"
|
||
|
|
]
|
||
|
|
|
||
|
|
missing_packages = []
|
||
|
|
for package in required_packages:
|
||
|
|
try:
|
||
|
|
__import__(package.replace('-', '_'))
|
||
|
|
except ImportError:
|
||
|
|
missing_packages.append(package)
|
||
|
|
|
||
|
|
if missing_packages:
|
||
|
|
print(f" ❌ Missing packages: {', '.join(missing_packages)}")
|
||
|
|
return False
|
||
|
|
|
||
|
|
print(f" ✅ All required packages available")
|
||
|
|
return True
|
||
|
|
|
||
|
|
def generate_test_report(self) -> None:
|
||
|
|
"""Generate a comprehensive test report"""
|
||
|
|
self._print_header("AUTH SERVICE TEST REPORT")
|
||
|
|
|
||
|
|
if not self.results:
|
||
|
|
print("No test results available")
|
||
|
|
return
|
||
|
|
|
||
|
|
# Summary table
|
||
|
|
print(f"\n{Colors.colorize('Test Category', Colors.BOLD):<25} "
|
||
|
|
f"{Colors.colorize('Status', Colors.BOLD):<12} "
|
||
|
|
f"{Colors.colorize('Duration', Colors.BOLD):<12} "
|
||
|
|
f"{Colors.colorize('Tests', Colors.BOLD):<15} "
|
||
|
|
f"{Colors.colorize('Success Rate', Colors.BOLD):<12}")
|
||
|
|
print("-" * 80)
|
||
|
|
|
||
|
|
total_duration = 0
|
||
|
|
total_tests = 0
|
||
|
|
total_passed = 0
|
||
|
|
|
||
|
|
for test_type, metrics in self.results.items():
|
||
|
|
if metrics.duration > 0:
|
||
|
|
total_duration += metrics.duration
|
||
|
|
total_tests += metrics.tests_run
|
||
|
|
total_passed += metrics.tests_passed
|
||
|
|
|
||
|
|
# Status
|
||
|
|
if metrics.tests_failed == 0 and metrics.tests_run > 0:
|
||
|
|
status = Colors.colorize("✅ PASSED", Colors.GREEN)
|
||
|
|
elif metrics.tests_run == 0:
|
||
|
|
status = Colors.colorize("⚪ SKIPPED", Colors.YELLOW)
|
||
|
|
else:
|
||
|
|
status = Colors.colorize("❌ FAILED", Colors.RED)
|
||
|
|
|
||
|
|
# Duration
|
||
|
|
duration_str = f"{metrics.duration:.2f}s"
|
||
|
|
|
||
|
|
# Tests count
|
||
|
|
if metrics.tests_run > 0:
|
||
|
|
tests_str = f"{metrics.tests_passed}/{metrics.tests_run}"
|
||
|
|
else:
|
||
|
|
tests_str = "0"
|
||
|
|
|
||
|
|
# Success rate
|
||
|
|
if metrics.tests_run > 0:
|
||
|
|
success_rate_str = f"{metrics.success_rate:.1f}%"
|
||
|
|
else:
|
||
|
|
success_rate_str = "N/A"
|
||
|
|
|
||
|
|
print(f"{test_type.replace('_', ' ').title():<25} "
|
||
|
|
f"{status:<20} "
|
||
|
|
f"{duration_str:<12} "
|
||
|
|
f"{tests_str:<15} "
|
||
|
|
f"{success_rate_str:<12}")
|
||
|
|
|
||
|
|
# Overall summary
|
||
|
|
print("-" * 80)
|
||
|
|
overall_success_rate = (total_passed / total_tests * 100) if total_tests > 0 else 0
|
||
|
|
overall_status = "✅ PASSED" if total_passed == total_tests and total_tests > 0 else "❌ FAILED"
|
||
|
|
|
||
|
|
print(f"{'OVERALL':<25} "
|
||
|
|
f"{Colors.colorize(overall_status, Colors.BOLD):<20} "
|
||
|
|
f"{total_duration:.2f}s{'':<6} "
|
||
|
|
f"{total_passed}/{total_tests}{'':11} "
|
||
|
|
f"{overall_success_rate:.1f}%")
|
||
|
|
|
||
|
|
print("\n" + "=" * 80)
|
||
|
|
|
||
|
|
# Recommendations
|
||
|
|
self._print_recommendations(overall_success_rate, total_tests)
|
||
|
|
|
||
|
|
def _print_recommendations(self, success_rate: float, total_tests: int):
|
||
|
|
"""Print recommendations based on test results"""
|
||
|
|
print(f"\n{Colors.colorize('📋 RECOMMENDATIONS', Colors.BOLD + Colors.CYAN)}")
|
||
|
|
|
||
|
|
if success_rate == 100 and total_tests > 0:
|
||
|
|
self._print_success("Excellent! All tests passed. Your auth service is ready for deployment.")
|
||
|
|
elif success_rate >= 90:
|
||
|
|
self._print_warning("Good test coverage. Review failed tests before deployment.")
|
||
|
|
elif success_rate >= 70:
|
||
|
|
self._print_warning("Moderate test coverage. Significant issues need fixing.")
|
||
|
|
else:
|
||
|
|
self._print_error("Poor test results. Major issues need addressing before deployment.")
|
||
|
|
|
||
|
|
# Specific recommendations
|
||
|
|
recommendations = []
|
||
|
|
|
||
|
|
if 'security_tests' in self.results:
|
||
|
|
security_metrics = self.results['security_tests']
|
||
|
|
if security_metrics.tests_failed > 0:
|
||
|
|
recommendations.append("🔒 Fix security test failures - critical for production")
|
||
|
|
|
||
|
|
if 'coverage_tests' in self.results:
|
||
|
|
coverage_metrics = self.results['coverage_tests']
|
||
|
|
if coverage_metrics.coverage_percentage < 80:
|
||
|
|
recommendations.append(f"📊 Increase test coverage (current: {coverage_metrics.coverage_percentage:.1f}%)")
|
||
|
|
|
||
|
|
if 'performance_tests' in self.results:
|
||
|
|
perf_metrics = self.results['performance_tests']
|
||
|
|
if perf_metrics.tests_failed > 0:
|
||
|
|
recommendations.append("⚡ Address performance issues")
|
||
|
|
|
||
|
|
if recommendations:
|
||
|
|
print("\n" + Colors.colorize("Next Steps:", Colors.BOLD))
|
||
|
|
for i, rec in enumerate(recommendations, 1):
|
||
|
|
print(f" {i}. {rec}")
|
||
|
|
|
||
|
|
def clean_test_artifacts(self) -> None:
|
||
|
|
"""Clean up test artifacts"""
|
||
|
|
self._print_step("Cleaning test artifacts", "🧹")
|
||
|
|
|
||
|
|
artifacts = [
|
||
|
|
".pytest_cache",
|
||
|
|
"htmlcov",
|
||
|
|
".coverage",
|
||
|
|
"coverage.xml",
|
||
|
|
"report.html",
|
||
|
|
"test-results.xml"
|
||
|
|
]
|
||
|
|
|
||
|
|
cleaned_count = 0
|
||
|
|
for artifact in artifacts:
|
||
|
|
artifact_path = self.project_root / artifact
|
||
|
|
if artifact_path.exists():
|
||
|
|
if artifact_path.is_dir():
|
||
|
|
import shutil
|
||
|
|
shutil.rmtree(artifact_path)
|
||
|
|
else:
|
||
|
|
artifact_path.unlink()
|
||
|
|
self._print_success(f"Removed {artifact}")
|
||
|
|
cleaned_count += 1
|
||
|
|
|
||
|
|
# Clean __pycache__ directories
|
||
|
|
pycache_count = 0
|
||
|
|
for pycache in self.project_root.rglob("__pycache__"):
|
||
|
|
import shutil
|
||
|
|
shutil.rmtree(pycache)
|
||
|
|
pycache_count += 1
|
||
|
|
|
||
|
|
# Clean .pyc files
|
||
|
|
pyc_count = 0
|
||
|
|
for pyc in self.project_root.rglob("*.pyc"):
|
||
|
|
pyc.unlink()
|
||
|
|
pyc_count += 1
|
||
|
|
|
||
|
|
if pycache_count > 0:
|
||
|
|
self._print_success(f"Removed {pycache_count} __pycache__ directories")
|
||
|
|
if pyc_count > 0:
|
||
|
|
self._print_success(f"Removed {pyc_count} .pyc files")
|
||
|
|
|
||
|
|
if cleaned_count == 0 and pycache_count == 0 and pyc_count == 0:
|
||
|
|
print(" 📁 No artifacts to clean")
|
||
|
|
else:
|
||
|
|
self._print_success("Test artifacts cleaned successfully")
|
||
|
|
|
||
|
|
def save_results_json(self, filename: str = "test_results.json") -> None:
|
||
|
|
"""Save test results to JSON file"""
|
||
|
|
results_data = {
|
||
|
|
"timestamp": datetime.now().isoformat(),
|
||
|
|
"test_categories": {}
|
||
|
|
}
|
||
|
|
|
||
|
|
for test_type, metrics in self.results.items():
|
||
|
|
results_data["test_categories"][test_type] = {
|
||
|
|
"duration": metrics.duration,
|
||
|
|
"tests_run": metrics.tests_run,
|
||
|
|
"tests_passed": metrics.tests_passed,
|
||
|
|
"tests_failed": metrics.tests_failed,
|
||
|
|
"tests_skipped": metrics.tests_skipped,
|
||
|
|
"success_rate": metrics.success_rate,
|
||
|
|
"coverage_percentage": metrics.coverage_percentage,
|
||
|
|
"warnings_count": metrics.warnings_count
|
||
|
|
}
|
||
|
|
|
||
|
|
with open(filename, 'w') as f:
|
||
|
|
json.dump(results_data, f, indent=2)
|
||
|
|
|
||
|
|
self._print_success(f"Test results saved to {filename}")
|
||
|
|
|
||
|
|
def main():
|
||
|
|
"""Main entry point for test runner"""
|
||
|
|
parser = argparse.ArgumentParser(
|
||
|
|
description="Auth Service Test Runner",
|
||
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||
|
|
epilog="""
|
||
|
|
Examples:
|
||
|
|
python run_tests.py # Run all tests
|
||
|
|
python run_tests.py --test-type security # Run security tests only
|
||
|
|
python run_tests.py --coverage # Run with coverage
|
||
|
|
python run_tests.py --parallel --workers 4 # Run in parallel
|
||
|
|
python run_tests.py --pattern "test_login" # Run specific test pattern
|
||
|
|
python run_tests.py --validate # Validate environment
|
||
|
|
python run_tests.py --clean # Clean test artifacts
|
||
|
|
"""
|
||
|
|
)
|
||
|
|
|
||
|
|
parser.add_argument("--test-type",
|
||
|
|
choices=["all", "unit", "integration", "api", "security", "performance", "fast"],
|
||
|
|
default="all",
|
||
|
|
help="Type of tests to run")
|
||
|
|
parser.add_argument("--coverage", action="store_true", help="Run with coverage")
|
||
|
|
parser.add_argument("--parallel", action="store_true", help="Run tests in parallel")
|
||
|
|
parser.add_argument("--workers", type=int, help="Number of parallel workers")
|
||
|
|
parser.add_argument("--pattern", type=str, help="Run specific test pattern")
|
||
|
|
parser.add_argument("--validate", action="store_true", help="Validate test environment")
|
||
|
|
parser.add_argument("--clean", action="store_true", help="Clean test artifacts")
|
||
|
|
parser.add_argument("--verbose", action="store_true", default=True, help="Verbose output")
|
||
|
|
parser.add_argument("--save-results", action="store_true", help="Save results to JSON file")
|
||
|
|
parser.add_argument("--quiet", action="store_true", help="Quiet mode (less output)")
|
||
|
|
|
||
|
|
args = parser.parse_args()
|
||
|
|
|
||
|
|
runner = AuthTestRunner()
|
||
|
|
|
||
|
|
# Print header
|
||
|
|
if not args.quiet:
|
||
|
|
runner._print_header("🧪 AUTH SERVICE TEST RUNNER 🧪")
|
||
|
|
|
||
|
|
# Clean artifacts if requested
|
||
|
|
if args.clean:
|
||
|
|
runner.clean_test_artifacts()
|
||
|
|
return
|
||
|
|
|
||
|
|
# Validate environment if requested
|
||
|
|
if args.validate:
|
||
|
|
success = runner.validate_test_environment()
|
||
|
|
if success:
|
||
|
|
runner._print_success("Test environment validation passed")
|
||
|
|
else:
|
||
|
|
runner._print_error("Test environment validation failed")
|
||
|
|
sys.exit(0 if success else 1)
|
||
|
|
|
||
|
|
# Validate environment before running tests
|
||
|
|
if not args.quiet:
|
||
|
|
if not runner.validate_test_environment():
|
||
|
|
runner._print_error("Test environment validation failed")
|
||
|
|
sys.exit(1)
|
||
|
|
|
||
|
|
success = True
|
||
|
|
|
||
|
|
try:
|
||
|
|
runner.overall_metrics.start()
|
||
|
|
|
||
|
|
if args.pattern:
|
||
|
|
success = runner.run_specific_test(args.pattern)
|
||
|
|
elif args.coverage:
|
||
|
|
success = runner.run_coverage_tests()
|
||
|
|
elif args.parallel:
|
||
|
|
success = runner.run_parallel_tests(args.workers)
|
||
|
|
elif args.test_type == "unit":
|
||
|
|
success = runner.run_unit_tests()
|
||
|
|
elif args.test_type == "integration":
|
||
|
|
success = runner.run_integration_tests()
|
||
|
|
elif args.test_type == "api":
|
||
|
|
success = runner.run_api_tests()
|
||
|
|
elif args.test_type == "security":
|
||
|
|
success = runner.run_security_tests()
|
||
|
|
elif args.test_type == "performance":
|
||
|
|
success = runner.run_performance_tests()
|
||
|
|
elif args.test_type == "fast":
|
||
|
|
success = runner.run_fast_tests()
|
||
|
|
else: # all
|
||
|
|
success = runner.run_all_tests(args.verbose)
|
||
|
|
|
||
|
|
runner.overall_metrics.stop()
|
||
|
|
|
||
|
|
if not args.quiet:
|
||
|
|
runner.generate_test_report()
|
||
|
|
|
||
|
|
if args.save_results:
|
||
|
|
runner.save_results_json()
|
||
|
|
|
||
|
|
except KeyboardInterrupt:
|
||
|
|
runner._print_error("Tests interrupted by user")
|
||
|
|
success = False
|
||
|
|
except Exception as e:
|
||
|
|
runner._print_error(f"Error running tests: {e}")
|
||
|
|
success = False
|
||
|
|
|
||
|
|
if success:
|
||
|
|
if not args.quiet:
|
||
|
|
runner._print_success("All tests completed successfully!")
|
||
|
|
sys.exit(0)
|
||
|
|
else:
|
||
|
|
if not args.quiet:
|
||
|
|
runner._print_error("Some tests failed!")
|
||
|
|
sys.exit(1)
|
||
|
|
|
||
|
|
if __name__ == "__main__":
|
||
|
|
main()
|