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

devdox_ai_locust/schemas/processing_result.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel, field_validator, ValidationInfo
+from typing import Optional, Type
+
+
+class SwaggerProcessingRequest(BaseModel):
+    swagger_url: Optional[str] = None
+
+    @field_validator("swagger_url", mode="before")
+    @classmethod
+    def coerce_to_string(
+        cls: Type["SwaggerProcessingRequest"], v: Optional[str]
+    ) -> Optional[str]:
+        if v is None:
+            return v
+        return str(v)
+
+    @field_validator("swagger_url")
+    @classmethod
+    def validate_url_when_source_is_url(
+        cls: Type["SwaggerProcessingRequest"], v: Optional[str], info: ValidationInfo
+    ) -> Optional[str]:
+        if info.data.get("swagger_source") == "url" and not v:
+            raise ValueError("swagger_url is required when source is url")
+        return v

devdox_ai_locust/templates/base_workflow.py.j2

@@ -0,0 +1,180 @@
+"""
+Locust performance tests for {{api_info.title}}
+
+API Information:
+- Title: {{api_info.title}}
+- Version: {{api_info.version}}
+- Base URL: {{api_info.base_url}}
+"""
+
+from locust import HttpUser, task, between, events, SequentialTaskSet
+import json
+import logging
+from typing import Dict, Any, Optional
+from urllib.parse import urljoin
+
+from test_data import TestDataGenerator
+from utils import ResponseValidator, RequestLogger, PerformanceMonitor
+from config import LoadTestConfig
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize components
+config = LoadTestConfig()
+data_generator = TestDataGenerator()
+response_validator = ResponseValidator()
+performance_monitor = PerformanceMonitor()
+
+
+class BaseTaskMethods:
+    """Mixin class with common task functionality - no inheritance conflicts"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._initialize_attributes()
+
+    def _initialize_attributes(self):
+        """Initialize all required attributes"""
+        if not hasattr(self, 'auth_token'):
+            self.auth_token = None
+        if not hasattr(self, 'user_data'):
+            self.user_data = {}
+        if not hasattr(self, 'request_count'):
+            self.request_count = 0
+        if not hasattr(self, 'default_headers'):
+            self._setup_authentication()
+            self._setup_headers()
+
+    def on_start(self):
+        """Initialize user session"""
+        self._initialize_attributes()
+        logger.info(f"TaskSet {self.__class__.__name__} started")
+
+    def on_stop(self):
+        """Cleanup when user stops"""
+        if hasattr(self, 'request_count'):
+            logger.info(f"TaskSet {self.__class__.__name__} stopped after {self.request_count} requests")
+        else:
+            logger.info(f"TaskSet {self.__class__.__name__} stopped after {self.request_count} requests")
+
+    def _setup_authentication(self):
+        """Setup authentication (override in subclasses if needed)"""
+        if not hasattr(self, 'auth_token'):
+            self.auth_token = None
+        if config.api_key:
+            self.auth_token = config.api_key
+
+    def _setup_headers(self):
+        """Setup default headers for all requests"""
+        if not hasattr(self, 'auth_token'):
+            self._setup_authentication()
+        self.default_headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "Locust-LoadTest/1.0"
+        }
+        if self.auth_token:
+            self.default_headers["Authorization"] = f"Bearer {self.auth_token}"
+
+    def make_request(self, method: str, path: str, **kwargs) -> Optional[Dict]:
+        """Make HTTP request with logging, validation, and monitoring"""
+        self._initialize_attributes()
+        self.request_count += 1
+
+        try:
+            # Merge headers
+            request_headers = {**self.default_headers, **kwargs.get("headers", {})}
+
+            # Set content-type for POST/PUT/PATCH
+            if method.upper() in ["POST", "PUT", "PATCH"]:
+                if "json" in kwargs:
+                    request_headers["Content-Type"] = "application/json"
+                elif "data" in kwargs and isinstance(kwargs["data"], dict):
+                    request_headers["Content-Type"] = "application/x-www-form-urlencoded"
+
+            kwargs["headers"] = request_headers
+
+            # Log request
+            RequestLogger.log_request(method, path, kwargs)
+
+            with self.client.request(
+                method=method,
+                url=urljoin(config.base_url, path),
+                catch_response=True,
+                **kwargs
+            ) as response:
+                # Validate and monitor
+                is_valid = response_validator.validate_response(response, method, path)
+                performance_monitor.record_response(response, method, path)
+
+                if not is_valid:
+                    response.failure(f"Response validation failed for {method} {path}")
+                    return None
+
+                try:
+                    return response.json() if response.content else None
+                except json.JSONDecodeError:
+                    if response.status_code < 400:
+                        return {"raw_content": response.text}
+                    response.failure(f"Invalid JSON response for {method} {path}")
+                    return None
+
+        except Exception as e:
+            logger.error(f"Request failed {method} {path}: {e}")
+            return None
+
+    def _store_response_data(self, method_name: str, data: Dict):
+        """Store response data for future requests"""
+        if not hasattr(self, 'user_data'):
+            self.user_data = {}
+        if data:
+            self.user_data[method_name] = data
+
+    def _get_stored_data(self, method_name: str, key: str = None):
+        """Retrieve stored response data from previous requests"""
+        stored_data = self.user_data.get(method_name)
+        if stored_data and key:
+            return stored_data.get(key)
+        return stored_data
+
+
+class BaseAPIUser(HttpUser):
+    """Base class for API users with common functionality"""
+
+    abstract = True
+    wait_time = between(0.5, 1.5)
+
+    def on_start(self):
+        """Initialize user session"""
+        self.auth_token = None
+        self.user_data = {}
+        self.request_count = 0
+
+        # Setup authentication if needed
+        self._setup_authentication()
+
+        # Initialize session headers
+        self._setup_headers()
+
+        logger.info(f"User {self.__class__.__name__} started")
+
+    def on_stop(self):
+        """Cleanup when user stops"""
+        logger.info(f"User {self.__class__.__name__} stopped after {self.request_count} requests")
+
+    def _setup_authentication(self):
+        """Setup authentication (override in subclasses if needed)"""
+        if config.api_key:
+            self.auth_token = config.api_key
+
+    def _setup_headers(self):
+        """Setup default headers for all requests"""
+        self.default_headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "Locust-LoadTest/1.0"
+        }
+        if self.auth_token:
+            self.default_headers["Authorization"] = f"Bearer {self.auth_token}"

devdox_ai_locust/templates/config.py.j2

@@ -0,0 +1,173 @@
+"""
+Configuration for Locust Load Tests
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Any
+from urllib.parse import urljoin
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@dataclass
+class PerformanceThresholds:
+    """Performance thresholds for test validation"""
+    max_response_time_ms: int = 2000  # Maximum acceptable response time
+    max_95th_percentile_ms: int = 5000  # 95th percentile response time
+    max_error_rate_percent: float = 1.0  # Maximum error rate percentage
+    min_requests_per_second: float = 10.0  # Minimum RPS threshold
+
+
+@dataclass
+class LoadTestScenario:
+    """Load test scenario configuration"""
+    name: str
+    users: int
+    spawn_rate: int
+    run_time: str
+    description: str
+
+
+class LoadTestConfig:
+    """Main configuration class for load tests"""
+
+    def __init__(self):
+        # API Configuration
+        self.base_url = os.getenv('API_BASE_URL', '{{api_info.base_url}}')
+        self.api_version = os.getenv('API_VERSION', '{{api_info.version}}')
+        self.api_title = '{{api_info.title}}'
+
+        # Authentication
+        self.api_key = os.getenv('API_KEY')
+        self.auth_token = os.getenv('AUTH_TOKEN')
+        self.username = os.getenv('API_USERNAME')
+        self.password = os.getenv('API_PASSWORD')
+
+        # Load Test Parameters
+        self.users = int(os.getenv('LOCUST_USERS', '10'))
+        self.spawn_rate = int(os.getenv('LOCUST_SPAWN_RATE', '2'))
+        self.run_time = os.getenv('LOCUST_RUN_TIME', '5m')
+        self.host = os.getenv('LOCUST_HOST', self.base_url)
+
+        # Test Data Configuration
+        self.use_realistic_data = os.getenv('USE_REALISTIC_DATA', 'true').lower() == 'true'
+        self.data_seed = int(os.getenv('DATA_SEED', '42'))
+
+        # Monitoring and Reporting
+        self.enable_monitoring = os.getenv('ENABLE_MONITORING', 'true').lower() == 'true'
+        self.report_output_dir = os.getenv('REPORT_OUTPUT_DIR', './reports')
+        self.log_level = os.getenv('LOG_LEVEL', 'INFO')
+
+        # Performance Thresholds
+        self.thresholds = PerformanceThresholds(
+            max_response_time_ms=int(os.getenv('MAX_RESPONSE_TIME_MS', '2000')),
+            max_95th_percentile_ms=int(os.getenv('MAX_95TH_PERCENTILE_MS', '5000')),
+            max_error_rate_percent=float(os.getenv('MAX_ERROR_RATE_PERCENT', '1.0')),
+            min_requests_per_second=float(os.getenv('MIN_REQUESTS_PER_SECOND', '10.0'))
+        )
+
+        # Test Scenarios
+        self.scenarios = self._load_test_scenarios()
+
+        # Request Configuration
+        self.request_timeout = int(os.getenv('REQUEST_TIMEOUT', '30'))
+        self.max_retries = int(os.getenv('MAX_RETRIES', '3'))
+
+        # Load Balancing and Distribution
+        self.enable_distributed = os.getenv('ENABLE_DISTRIBUTED', 'false').lower() == 'true'
+        self.master_host = os.getenv('LOCUST_MASTER_HOST', 'localhost')
+        self.master_port = int(os.getenv('LOCUST_MASTER_PORT', '5557'))
+
+        # Feature Flags
+        self.enable_custom_flows = os.getenv('ENABLE_CUSTOM_FLOWS', 'true').lower() == 'true'
+        self.enable_response_validation = os.getenv('ENABLE_RESPONSE_VALIDATION', 'true').lower() == 'true'
+        self.enable_performance_monitoring = os.getenv('ENABLE_PERF_MONITORING', 'true').lower() == 'true'
+
+    def _load_test_scenarios(self) -> Dict[str, LoadTestScenario]:
+        """Load predefined test scenarios"""
+        return {
+            'smoke': LoadTestScenario(
+                name='Smoke Test',
+                users=5,
+                spawn_rate=1,
+                run_time='2m',
+                description='Quick smoke test to verify basic functionality'
+            ),
+            'load': LoadTestScenario(
+                name='Load Test',
+                users=50,
+                spawn_rate=5,
+                run_time='10m',
+                description='Standard load test with moderate user count'
+            ),
+            'stress': LoadTestScenario(
+                name='Stress Test',
+                users=200,
+                spawn_rate=10,
+                run_time='15m',
+                description='Stress test to find breaking points'
+            ),
+            'spike': LoadTestScenario(
+                name='Spike Test',
+                users=500,
+                spawn_rate=50,
+                run_time='5m',
+                description='Spike test with rapid user ramp-up'
+            ),
+            'soak': LoadTestScenario(
+                name='Soak Test',
+                users=100,
+                spawn_rate=5,
+                run_time='60m',
+                description='Long-running test to identify memory leaks'
+            )
+        }
+
+    def get_scenario(self, scenario_name: str) -> Optional[LoadTestScenario]:
+        """Get specific test scenario"""
+        return self.scenarios.get(scenario_name)
+
+    def get_headers(self) -> Dict[str, str]:
+        """Get default headers for requests"""
+        headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'User-Agent': 'LoadTest/1.0'
+        }
+
+        if self.api_key:
+            headers['X-API-Key'] = self.api_key
+
+        if self.auth_token:
+            headers['Authorization'] = f'Bearer {self.auth_token}'
+
+        return headers
+
+    def get_full_url(self, path: str) -> str:
+        """Construct full URL from path"""
+        return urljoin(self.base_url, path.lstrip('/'))
+
+    def validate_config(self) -> List[str]:
+        """Validate configuration and return any errors"""
+        errors = []
+
+        if not self.base_url:
+            errors.append("Base URL is required")
+
+        if self.users <= 0:
+            errors.append("User count must be positive")
+
+        if self.spawn_rate <= 0:
+            errors.append("Spawn rate must be positive")
+
+        if self.spawn_rate > self.users:
+            errors.append("Spawn rate cannot exceed user count")
+
+        return errors
+
+
+# Global configuration instance
+config = LoadTestConfig()
+

devdox_ai_locust/templates/custom_flows.py.j2

@@ -0,0 +1,95 @@
+import random
+import time
+from typing import Dict, List, Any, Optional
+from locust import HttpUser, task, between, SequentialTaskSet
+import logging
+
+from test_data import TestDataGenerator
+from utils import ResponseValidator, data_manager
+
+logger = logging.getLogger(__name__)
+
+
+class APIWorkflowUser(HttpUser):
+    """User that executes complex workflows"""
+
+    wait_time = between(2, 8)
+    weight = 2
+
+    tasks = []
+
+    def on_start(self):
+        self.workflow_data = {}
+        logger.info("Workflow user started")
+
+    def on_stop(self):
+        logger.info("Workflow user stopped")
+
+
+class DataDependentFlow(SequentialTaskSet):
+    """Flow that demonstrates data dependencies between requests"""
+
+    @task
+    def create_resource(self):
+        resource_data = {
+            'name': f"resource_{random.randint(1000, 9999)}",
+            'type': random.choice(['document', 'image', 'video']),
+            'metadata': {
+                'created_by': 'load_test',
+                'test_run': True
+            }
+        }
+
+        response_data = self.user.make_request(
+            method="post",
+            url="/resources",
+            json=resource_data
+        )
+
+        if response_data and 'id' in response_data:
+            data_manager.store_shared_data('last_resource_id', response_data['id'])
+            self.user.user_data['resource_id'] = response_data['id']
+
+    @task
+    def update_resource(self):
+        resource_id = self.user.user_data.get('resource_id') or data_manager.get_shared_data('last_resource_id')
+        if resource_id:
+            update_data = {
+                'name': f"updated_resource_{random.randint(1000, 9999)}",
+                'status': 'active'
+            }
+            self.user.make_request(
+                method="put",
+                url=f"/resources/{resource_id}",
+                json=update_data
+            )
+
+    @task
+    def get_resource(self):
+        resource_id = self.user.user_data.get('resource_id')
+        if resource_id:
+            self.user.make_request(
+                method="get",
+                url=f"/resources/{resource_id}"
+            )
+
+    @task
+    def delete_resource(self):
+        resource_id = self.user.user_data.get('resource_id')
+        if resource_id:
+            self.user.make_request(
+                method="delete",
+                url=f"/resources/{resource_id}"
+            )
+            self.user.user_data.pop('resource_id', None)
+
+
+class ComplexFlowUser(HttpUser):
+    """User that executes complex, realistic flows"""
+
+    wait_time = between(3, 10)
+    weight = 1
+
+    tasks = [
+        DataDependentFlow
+    ]

devdox_ai_locust/templates/endpoint_template.py.j2

@@ -0,0 +1,34 @@
+"""
+Locust performance tests for {{group}}
+Generated on: {{ generated_at }}
+
+API Information:
+- Title: {{ api_info.title }}
+- Version: {{ api_info.version }}
+- Base URL: {{ api_info.base_url }}
+"""
+
+from locust import HttpUser, task, between, events, SequentialTaskSet
+from locust.runners import MasterRunner
+import logging
+
+from test_data import TestDataGenerator
+from utils import ResponseValidator, RequestLogger, PerformanceMonitor
+from workflows.base_workflow import BaseAPIUser, BaseTaskMethods
+from config import LoadTestConfig
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize components
+config = LoadTestConfig()
+data_generator = TestDataGenerator()
+response_validator = ResponseValidator()
+performance_monitor = PerformanceMonitor()
+
+
+class {{group}}TaskMethods(SequentialTaskSet, BaseTaskMethods):
+    """Mixin class containing all API task methods"""
+
+    {{task_methods_content}}

devdox_ai_locust/templates/env.example.j2

@@ -0,0 +1,3 @@
+{% for key, value in environment_vars.items() -%}
+{{ key }}={{ value }}
+{% endfor %}

devdox_ai_locust/templates/fallback_locust.py.j2

@@ -0,0 +1,25 @@
+"""
+    Fallback Locust test file for {api_info.get('title', 'API')}
+"""
+
+from locust import HttpUser, task, between
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class BasicAPIUser(HttpUser):
+        wait_time = between(1, 5)
+
+        @task(1)
+        def health_check(self):
+            """Basic health check"""
+            with self.client.get("/health", catch_response=True) as response:
+                if response.status_code == 200:
+                    response.success()
+                else:
+                    response.failure(f"Health check failed: {{response.status_code}}")
+
+
+if __name__ == "__main__":
+    print("Running fallback Locust test for {{api_info.title}}")

devdox_ai_locust/templates/locust.py.j2

@@ -0,0 +1,70 @@
+"""
+Locust performance tests for {{ api_info.get('title', 'API') }}
+Generated on: {{ generated_at }}
+
+API Information:
+- Title: {{ api_info.get('title', 'Unknown') }}
+- Version: {{ api_info.get('version', 'Unknown') }}
+- Base URL: {{ api_info.get('base_url', 'http://localhost') }}
+"""
+
+from locust import HttpUser, task, between, events
+from locust.runners import MasterRunner
+import json
+import random
+import logging
+from typing import Dict, Any, Optional
+from urllib.parse import urljoin
+from workflows.base_workflow import BaseAPIUser
+{{ import_group_tasks }}
+
+from test_data import TestDataGenerator
+from utils import ResponseValidator, RequestLogger, PerformanceMonitor
+from config import LoadTestConfig
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize components
+config = LoadTestConfig()
+data_generator = TestDataGenerator()
+response_validator = ResponseValidator()
+performance_monitor = PerformanceMonitor()
+
+
+class APITaskMethods:
+    """Mixin class containing all API task methods"""
+
+    {{ task_methods_content }}
+
+    tasks = {{ tasks_str }}
+
+
+{{ generated_task_classes }}
+
+
+# Event handlers
+@events.request.add_listener
+def on_request(request_type, name, response_time, response_length, exception, context, **kwargs):
+    performance_monitor.on_request_event(
+        request_type, name, response_time, response_length, exception, context
+    )
+
+
+@events.test_start.add_listener
+def on_test_start(environment, **kwargs):
+    logger.info("Load test starting...")
+    performance_monitor.test_start()
+
+
+@events.test_stop.add_listener
+def on_test_stop(environment, **kwargs):
+    logger.info("Load test stopping...")
+    performance_monitor.test_stop()
+    performance_monitor.generate_report()
+
+
+if __name__ == "__main__":
+    from locust.main import main
+    main()

devdox_ai_locust/templates/readme.md.j2

@@ -0,0 +1,46 @@
+# 🚀 Load Testing Suite for {{ api_info.title }}
+
+[![Python](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![Locust](https://img.shields.io/badge/locust-2.15+-green.svg)](https://locust.io/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Professional-grade performance testing suite for **{{ api_info.title }} {{ api_info.version }}** built with Locust.
+
+{% if api_info.description -%}
+{{ api_info.description }}
+{% endif %}
+
+## 📋 Table of Contents
+
+- [Quick Start](#-quick-start)
+- [Test Scenarios](#-test-scenarios)
+- [Configuration](#-configuration)
+- [Running Tests](#-running-tests)
+- [Monitoring & Reports](#-monitoring--reports)
+- [Advanced Features](#-advanced-features)
+- [Troubleshooting](#-troubleshooting)
+- [Best Practices](#-best-practices)
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- **Python 3.8+** with pip
+- **Network access** to the target API
+- **Minimum 2GB RAM** for load testing
+
+### Installation
+```bash
+# 1. Clone or download the test suite
+git clone <repository-url>
+cd load-testing-suite
+
+# 2. Install dependencies
+pip install -r requirements.txt
+
+# 3. Configure environment
+cp .env.example .env
+# Edit .env with your API configuration
+
+# 4. Run your first test
+locust -f locust.py

devdox_ai_locust/templates/requirement.txt.j2

@@ -0,0 +1,31 @@
+# Core Locust dependencies
+locust>=2.15.0,<3.0.0
+
+# HTTP and API testing
+requests>=2.31.0
+urllib3>=1.26.0
+
+# Data generation and manipulation
+python-dateutil>=2.8.0
+
+# Data handling
+pandas>=2.0.0
+numpy>=1.24.0
+
+# Configuration and environment
+python-dotenv>=1.0.0
+pydantic>=2.0.0
+
+# Monitoring and reporting
+psutil>=5.9.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+
+# Logging and debugging
+structlog>=23.0.0
+colorama>=0.4.6
+Faker==37.6.0
+
+# Optional: Database connectivity
+# psycopg2-binary>=2.9.0  # PostgreSQL
+# pymongo>=4.3.0  # MongoDB