devdox-ai-locust 0.1.1__py3-none-any.whl

devdox_ai_locust/templates/test_data.py.j2

@@ -0,0 +1,276 @@
+"""
+Test Data Generator for Locust Performance Tests
+
+Provides realistic test data generation for API endpoints.
+"""
+
+import random
+import string
+import uuid
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Union
+from faker import Faker
+import json
+
+fake = Faker()
+
+
+class TestDataGenerator:
+    """Generates realistic test data for API testing"""
+
+    def __init__(self, seed: Optional[int] = None):
+        if seed:
+            random.seed(seed)
+            Faker.seed(seed)
+
+        self.generated_ids = set()
+        self.user_sessions = {}
+
+    def generate_json_data(self, schema: Dict[str, Any], required_only: bool = False) -> Dict[str, Any]:
+        """
+        Generate realistic JSON data based on JSON Schema
+
+        Args:
+            schema: JSON Schema dictionary
+            required_only: If True, only generate required fields
+
+        Returns:
+            Dictionary with generated test data
+        """
+        if not isinstance(schema, dict):
+            return {}
+
+        schema_type = schema.get('type', 'object')
+
+        if schema_type == 'object':
+            return self._generate_object_data(schema, required_only)
+        elif schema_type == 'array':
+            return self._generate_array_data(schema)
+        elif schema_type == 'string':
+            return self._generate_string_value(schema)
+        elif schema_type == 'integer':
+            return self._generate_integer_value(schema)
+        elif schema_type == 'number':
+            return self._generate_number_value(schema)
+        elif schema_type == 'boolean':
+            return self._generate_boolean_value(schema)
+        else:
+            return None
+
+    def _generate_object_data(self, schema: Dict[str, Any], required_only: bool = False) -> Dict[str, Any]:
+        """Generate object data from schema properties"""
+        result = {}
+        properties = schema.get('properties', {})
+        required = schema.get('required', [])
+
+        for prop_name, prop_schema in properties.items():
+            if required_only and prop_name not in required:
+                continue
+
+            if '$ref' in prop_schema:
+                result[prop_name] = self._handle_reference(prop_schema['$ref'])
+
+        return result
+
+    def _generate_array_data(self, schema: Dict[str, Any]) -> List[Any]:
+        """Generate array data from schema"""
+        items_schema = schema.get('items', {})
+        min_items = schema.get('minItems', 1)
+        max_items = schema.get('maxItems', 3)
+
+        array_length = random.randint(min_items, max_items)
+        result = []
+
+        for _ in range(array_length):
+            if '$ref' in items_schema:
+                result.append(self._handle_reference(items_schema['$ref']))
+            else:
+                result.append(self.generate_json_data(items_schema))
+
+        return result
+
+    def _generate_integer_value(self, schema: Dict[str, Any]) -> int:
+        """Generate integer value based on schema constraints"""
+        minimum = schema.get('minimum', 0)
+        maximum = schema.get('maximum', 1000)
+        multiple_of = schema.get('multipleOf')
+
+        value = random.randint(minimum, maximum)
+
+        if multiple_of:
+            value = (value // multiple_of) * multiple_of
+
+        return value
+
+    def _generate_number_value(self, schema: Dict[str, Any]) -> float:
+        """Generate number/float value based on schema constraints"""
+        minimum = schema.get('minimum', 0.0)
+        maximum = schema.get('maximum', 1000.0)
+        multiple_of = schema.get('multipleOf')
+
+        value = random.uniform(minimum, maximum)
+
+        if multiple_of:
+            value = round((value / multiple_of)) * multiple_of
+        else:
+            value = round(value, 2)
+
+        return value
+
+    def _generate_boolean_value(self, schema: Dict[str, Any]) -> bool:
+        """Generate boolean value"""
+        return random.choice([True, False])
+
+    def _handle_reference(self, ref: str) -> Any:
+        """Handle $ref references in schema"""
+        ref_name = ref.split('/')[-1]
+        ref_lower = ref_name.lower()
+
+        if 'hosting' in ref_lower or 'provider' in ref_lower:
+            return random.choice(['github', 'gitlab', 'bitbucket'])
+        elif 'role' in ref_lower:
+            return random.choice(['admin', 'user', 'viewer'])
+        elif 'status' in ref_lower:
+            return random.choice(['active', 'inactive', 'pending'])
+        elif 'type' in ref_lower:
+            return random.choice(['primary', 'secondary', 'tertiary'])
+        else:
+            return f"{ref_name.lower()}_value_{random.randint(1, 100)}"
+
+    def _generate_by_name_pattern(self, prop_name: str) -> str:
+        """Generate value based on property name patterns as fallback"""
+        prop_name_lower = prop_name.lower()
+
+        if 'email' in prop_name_lower:
+            return fake.email()
+        elif any(keyword in prop_name_lower for keyword in ['name', 'label']):
+            return fake.catch_phrase()
+        elif any(keyword in prop_name_lower for keyword in ['token', 'key']):
+            return ''.join(random.choices(string.ascii_letters + string.digits, k=32))
+        elif 'id' in prop_name_lower:
+            return str(uuid.uuid4())
+        elif 'url' in prop_name_lower:
+            return fake.url()
+        else:
+            return self.random_string(10)
+
+    def _generate_string_value(self, schema: Dict[str, Any], prop_name: str = "") -> str:
+        """Generate string value based on schema constraints and property name"""
+        min_length = schema.get('minLength', 1)
+        max_length = schema.get('maxLength', 50)
+        enum_values = schema.get('enum')
+        prop_name_lower = prop_name.lower()
+
+        if enum_values:
+            return random.choice(enum_values)
+
+        if any(keyword in prop_name_lower for keyword in ['email', 'mail']):
+            return fake.email()
+
+        if any(keyword in prop_name_lower for keyword in ['name', 'label', 'title']):
+            if 'first' in prop_name_lower:
+                return fake.first_name()
+            elif 'last' in prop_name_lower:
+                return fake.last_name()
+            elif 'company' in prop_name_lower:
+                return fake.company()
+            else:
+                return fake.catch_phrase()[:max_length]
+
+        if any(keyword in prop_name_lower for keyword in ['token', 'key', 'secret', 'password']):
+            token_length = min(max_length, 32)
+            return ''.join(random.choices(string.ascii_letters + string.digits, k=token_length))
+
+        if any(keyword in prop_name_lower for keyword in ['url', 'uri', 'endpoint']):
+            return fake.url()
+
+        if 'phone' in prop_name_lower:
+            return fake.phone_number()
+
+        if 'address' in prop_name_lower:
+            return fake.address().replace('\\n', ', ')
+
+        if any(keyword in prop_name_lower for keyword in ['description', 'comment', 'note', 'text']):
+            return fake.text(max_nb_chars=max_length)
+
+        if any(keyword in prop_name_lower for keyword in ['id', 'uuid']):
+            return str(uuid.uuid4())
+
+        actual_length = min(max_length, max(min_length, random.randint(5, 20)))
+        return ''.join(random.choices(string.ascii_letters + string.digits, k=actual_length))
+
+    def generate_string(self, length: int = 10, pattern: str = None, default: str = None) -> str:
+        if default:
+            return default
+
+        if pattern:
+            if 'email' in pattern.lower():
+                return fake.email()
+            elif 'name' in pattern.lower():
+                return fake.name()
+            elif 'phone' in pattern.lower():
+                return fake.phone_number()
+            elif 'address' in pattern.lower():
+                return fake.address()
+            elif 'url' in pattern.lower():
+                return fake.url()
+            elif 'uuid' in pattern.lower():
+                return str(uuid.uuid4())
+
+        return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
+
+    def generate_integer(self, min_val: int = 1, max_val: int = 1000, default: int = None) -> int:
+        if default is not None:
+            return default
+        return random.randint(min_val, max_val)
+
+    def generate_float(self, min_val: float = 0.0, max_val: float = 1000.0, default: float = None) -> float:
+        if default is not None:
+            return default
+        return round(random.uniform(min_val, max_val), 2)
+
+    def generate_boolean(self, default: bool = None) -> bool:
+        if default is not None:
+            return default
+        return random.choice([True, False])
+
+    def generate_id(self, prefix: str = "", id_type: str = "uuid") -> str:
+        if id_type == "uuid":
+            new_id = str(uuid.uuid4())
+        elif id_type == "incremental":
+            new_id = f"{len(self.generated_ids) + 1}"
+        else:
+            new_id = ''.join(random.choices(string.ascii_letters + string.digits, k=8))
+
+        if prefix:
+            new_id = f"{prefix}_{new_id}"
+
+        self.generated_ids.add(new_id)
+        return new_id
+
+    def generate_email(self) -> str:
+        return fake.email()
+
+    def random_string(self, length: int = 10) -> str:
+        return ''.join(random.choices(string.ascii_letters, k=length))
+
+    def random_int(self, min_val: int = 0, max_val: int = 1000) -> int:
+        return random.randint(min_val, max_val)
+
+    def random_float(self, min_val: float = 0.0, max_val: float = 1000.0) -> float:
+        return random.uniform(min_val, max_val)
+
+    def random_bool(self) -> bool:
+        return random.choice([True, False])
+
+    def random_uuid(self) -> str:
+        return str(uuid.uuid4())
+
+    def random_date(self, start_days_ago: int = 365, end_days_ahead: int = 365) -> str:
+        start_date = datetime.now() - timedelta(days=start_days_ago)
+        end_date = datetime.now() + timedelta(days=end_days_ahead)
+        return fake.date_between(start_date=start_date, end_date=end_date).isoformat()
+
+
+# Global instance for easy access
+test_data_generator = TestDataGenerator()

devdox_ai_locust/templates/utils.py.j2

@@ -0,0 +1,335 @@
+"""
+Utility classes for Locust load testing
+"""
+
+import json
+import logging
+import time
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+import csv
+from dataclasses import dataclass, asdict
+import statistics
+from collections import defaultdict
+
+import requests
+from locust.runners import MasterRunner
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ResponseMetric:
+    """Response metric data structure"""
+    method: str
+    endpoint: str
+    response_time: float
+    status_code: int
+    response_size: int
+    timestamp: datetime
+    success: bool
+    error_message: Optional[str] = None
+
+
+class ResponseValidator:
+    """Validates HTTP responses against expected criteria"""
+
+    def __init__(self):
+        self.validation_rules = {
+            'GET': {
+                'expected_status': [200, 202, 206],
+                'max_response_time_ms': 2000,
+                'required_headers': ['content-type'],
+                'forbidden_headers': ['x-debug', 'x-error-detail']
+            },
+            'POST': {
+                'expected_status': [200, 201, 202],
+                'max_response_time_ms': 3000,
+                'required_headers': ['content-type']
+            },
+            'PUT': {
+                'expected_status': [200, 202, 204],
+                'max_response_time_ms': 3000,
+                'required_headers': ['content-type']
+            },
+            'PATCH': {
+                'expected_status': [200, 202, 204],
+                'max_response_time_ms': 3000,
+                'required_headers': ['content-type']
+            },
+            'DELETE': {
+                'expected_status': [200, 202, 204],
+                'max_response_time_ms': 2000
+            }
+        }
+
+    def validate_response(self, response, method: str, endpoint: str) -> bool:
+        """Validate HTTP response against expected criteria"""
+        is_valid = True
+        method_upper = method.upper()
+        rules = self.validation_rules.get(method_upper, {})
+
+        # Validate status code
+        expected_status = rules.get('expected_status', [200])
+        if response.status_code not in expected_status:
+            logger.warning(f"Unexpected status code {response.status_code} for {method_upper} {endpoint}")
+            is_valid = False
+
+        # Validate response time
+        max_time = rules.get('max_response_time_ms', 5000)
+        if response.elapsed.total_seconds() * 1000 > max_time:
+            logger.warning(f"Slow response {response.elapsed.total_seconds() * 1000:.2f}ms for {method_upper} {endpoint}")
+            is_valid = False
+
+        # Check forbidden headers (security)
+        forbidden_headers = rules.get('forbidden_headers', [])
+        for header in forbidden_headers:
+            if header.lower() in [h.lower() for h in response.headers.keys()]:
+                logger.warning(f"Forbidden header '{header}' present for {method_upper} {endpoint}")
+                is_valid = False
+
+        # Validate JSON response structure
+        if response.status_code < 400 and 'application/json' in response.headers.get('content-type', ''):
+            try:
+                json_data = response.json()
+                if not self._validate_json_structure(json_data, method_upper, endpoint):
+                    is_valid = False
+            except json.JSONDecodeError:
+                logger.warning(f"Invalid JSON response for {method_upper} {endpoint}")
+                is_valid = False
+
+        return is_valid
+
+    def _validate_json_structure(self, json_data: Any, method: str, endpoint: str) -> bool:
+        """Validate JSON response structure"""
+        if method == 'GET' and isinstance(json_data, list):
+            if json_data and isinstance(json_data[0], dict):
+                return 'id' in json_data[0] or len(json_data[0]) > 0
+        elif method in ['POST', 'PUT', 'PATCH'] and isinstance(json_data, dict):
+            return len(json_data) > 0
+        return True
+
+    def add_custom_validation(self, method: str, validation_func):
+        """Add custom validation function for specific method"""
+        if not hasattr(self, 'custom_validators'):
+            self.custom_validators = {}
+        self.custom_validators[method] = validation_func
+
+
+class RequestLogger:
+    """Logs HTTP requests for debugging and analysis"""
+
+    def __init__(self, log_file: str = "requests.log"):
+        self.log_file = log_file
+        self.requests_logged = 0
+        self.file_handler = logging.FileHandler(log_file)
+        self.file_handler.setLevel(logging.INFO)
+        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+        self.file_handler.setFormatter(formatter)
+
+        self.request_logger = logging.getLogger('request_logger')
+        self.request_logger.addHandler(self.file_handler)
+        self.request_logger.setLevel(logging.INFO)
+
+    @staticmethod
+    def log_request(method: str, url: str, kwargs: Dict):
+        logger.info(f"REQUEST: {method.upper()} {url}")
+        if 'params' in kwargs and kwargs['params']:
+            logger.debug(f"Query params: {kwargs['params']}")
+        if 'json' in kwargs and kwargs['json']:
+            logger.debug(f"JSON body: {json.dumps(kwargs['json'], indent=2)}")
+        if 'data' in kwargs and kwargs['data']:
+            logger.debug(f"Form data: {kwargs['data']}")
+
+    def log_response(self, response, method: str, url: str):
+        self.requests_logged += 1
+        log_entry = {
+            'timestamp': datetime.now().isoformat(),
+            'method': method.upper(),
+            'url': url,
+            'status_code': response.status_code,
+            'response_time_ms': response.elapsed.total_seconds() * 1000,
+            'response_size': len(response.content) if response.content else 0
+        }
+        self.request_logger.info(json.dumps(log_entry))
+        if response.status_code >= 400:
+            logger.error(f"ERROR RESPONSE: {response.status_code} for {method.upper()} {url}")
+            if response.text:
+                logger.error(f"Error details: {response.text[:500]}")
+
+
+class PerformanceMonitor:
+    """Monitors and reports performance metrics"""
+
+    def __init__(self):
+        self.metrics: List[ResponseMetric] = []
+        self.start_time = None
+        self.end_time = None
+        self.request_counts = defaultdict(int)
+        self.error_counts = defaultdict(int)
+
+    def test_start(self):
+        self.start_time = datetime.now()
+        logger.info("Performance monitoring started")
+
+    def test_stop(self):
+        self.end_time = datetime.now()
+        logger.info("Performance monitoring stopped")
+
+    def record_response(self, response, method: str, endpoint: str):
+        metric = ResponseMetric(
+            method=method.upper(),
+            endpoint=endpoint,
+            response_time=response.elapsed.total_seconds() * 1000,
+            status_code=response.status_code,
+            response_size=len(response.content) if response.content else 0,
+            timestamp=datetime.now(),
+            success=response.status_code < 400
+        )
+        if not metric.success:
+            metric.error_message = response.text[:200]
+        self.metrics.append(metric)
+        endpoint_key = f"{method.upper()} {endpoint}"
+        self.request_counts[endpoint_key] += 1
+        if not metric.success:
+            self.error_counts[endpoint_key] += 1
+
+    def on_request_event(self, request_type, name, response_time, response_length, exception, context):
+        if exception:
+            logger.error(f"Request failed: {request_type} {name} - {exception}")
+
+    def get_statistics(self) -> Dict[str, Any]:
+        if not self.metrics:
+            return {}
+        response_times = [m.response_time for m in self.metrics]
+        successful_requests = [m for m in self.metrics if m.success]
+        stats = {
+            'total_requests': len(self.metrics),
+            'successful_requests': len(successful_requests),
+            'failed_requests': len(self.metrics) - len(successful_requests),
+            'error_rate': (len(self.metrics) - len(successful_requests)) / len(self.metrics) * 100,
+            'response_times': {
+                'min': min(response_times),
+                'max': max(response_times),
+                'mean': statistics.mean(response_times),
+                'median': statistics.median(response_times),
+                'p95': self._percentile(response_times, 95),
+                'p99': self._percentile(response_times, 99)
+            }
+        }
+        if self.start_time and self.end_time:
+            duration = (self.end_time - self.start_time).total_seconds()
+            stats['test_duration_seconds'] = duration
+            stats['requests_per_second'] = len(self.metrics) / duration
+        stats['endpoints'] = self._get_endpoint_stats()
+        return stats
+
+    def _percentile(self, data: List[float], percentile: int) -> float:
+        sorted_data = sorted(data)
+        index = int((percentile / 100) * len(sorted_data))
+        return sorted_data[min(index, len(sorted_data) - 1)]
+
+    def _get_endpoint_stats(self) -> Dict[str, Dict]:
+        endpoint_stats = {}
+        for endpoint_key in self.request_counts.keys():
+            endpoint_metrics = [m for m in self.metrics if f"{m.method} {m.endpoint}" == endpoint_key]
+            if endpoint_metrics:
+                response_times = [m.response_time for m in endpoint_metrics]
+                successful = len([m for m in endpoint_metrics if m.success])
+                endpoint_stats[endpoint_key] = {
+                    'total_requests': len(endpoint_metrics),
+                    'successful_requests': successful,
+                    'error_rate': (len(endpoint_metrics) - successful) / len(endpoint_metrics) * 100,
+                    'avg_response_time': statistics.mean(response_times),
+                    'p95_response_time': self._percentile(response_times, 95)
+                }
+        return endpoint_stats
+
+    def generate_report(self, output_dir: str = "./reports"):
+        Path(output_dir).mkdir(exist_ok=True)
+        stats = self.get_statistics()
+
+        json_file = Path(output_dir) / f"performance_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        with open(json_file, 'w') as f:
+            json.dump(stats, f, indent=2, default=str)
+
+        csv_file = Path(output_dir) / f"performance_metrics_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        with open(csv_file, 'w', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow(['timestamp', 'method', 'endpoint', 'response_time_ms', 'status_code', 'success'])
+            for metric in self.metrics:
+                writer.writerow([
+                    metric.timestamp,
+                    metric.method,
+                    metric.endpoint,
+                    metric.response_time,
+                    metric.status_code,
+                    metric.success
+                ])
+
+        self._generate_summary_report(stats, output_dir)
+        logger.info(f"Performance reports generated in {output_dir}")
+
+    def _generate_summary_report(self, stats: Dict, output_dir: str):
+        summary_file = Path(output_dir) / f"summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+        with open(summary_file, 'w') as f:
+            f.write("PERFORMANCE TEST SUMMARY\n")
+            f.write("=" * 50 + "\n\n")
+            f.write(f"Test Duration: {stats.get('test_duration_seconds', 0):.2f} seconds\n")
+            f.write(f"Total Requests: {stats.get('total_requests', 0)}\n")
+            f.write(f"Successful Requests: {stats.get('successful_requests', 0)}\n")
+            f.write(f"Failed Requests: {stats.get('failed_requests', 0)}\n")
+            f.write(f"Error Rate: {stats.get('error_rate', 0):.2f}%\n")
+            f.write(f"Requests/Second: {stats.get('requests_per_second', 0):.2f}\n\n")
+
+            response_times = stats.get('response_times', {})
+            f.write("RESPONSE TIMES\n")
+            f.write("-" * 20 + "\n")
+            f.write(f"Min: {response_times.get('min', 0):.2f}ms\n")
+            f.write(f"Max: {response_times.get('max', 0):.2f}ms\n")
+            f.write(f"Mean: {response_times.get('mean', 0):.2f}ms\n")
+            f.write(f"Median: {response_times.get('median', 0):.2f}ms\n")
+            f.write(f"95th Percentile: {response_times.get('p95', 0):.2f}ms\n")
+            f.write(f"99th Percentile: {response_times.get('p99', 0):.2f}ms\n\n")
+
+            endpoints = stats.get('endpoints', {})
+            if endpoints:
+                f.write("PER-ENDPOINT STATISTICS\n")
+                f.write("-" * 30 + "\n")
+                for endpoint, endpoint_stats in endpoints.items():
+                    f.write(f"\n{endpoint}:\n")
+                    f.write(f"  Requests: {endpoint_stats['total_requests']}\n")
+                    f.write(f"  Error Rate: {endpoint_stats['error_rate']:.2f}%\n")
+                    f.write(f"  Avg Response Time: {endpoint_stats['avg_response_time']:.2f}ms\n")
+                    f.write(f"  95th Percentile: {endpoint_stats['p95_response_time']:.2f}ms\n")
+
+
+class DataManager:
+    """Manages test data and state across users"""
+
+    def __init__(self):
+        self.shared_data = {}
+        self.user_data = {}
+
+    def store_shared_data(self, key: str, value: Any):
+        self.shared_data[key] = value
+
+    def get_shared_data(self, key: str) -> Any:
+        return self.shared_data.get(key)
+
+    def store_user_data(self, user_id: str, key: str, value: Any):
+        if user_id not in self.user_data:
+            self.user_data[user_id] = {}
+        self.user_data[user_id][key] = value
+
+    def get_user_data(self, user_id: str, key: str) -> Any:
+        return self.user_data.get(user_id, {}).get(key)
+
+    def cleanup_user_data(self, user_id: str):
+        if user_id in self.user_data:
+            del self.user_data[user_id]
+
+
+# Global instances
+data_manager = DataManager()