api-mocker 0.1.0__py3-none-any.whl

api_mocker/recorder.py

@@ -0,0 +1,266 @@
+import json
+import time
+from typing import Dict, List, Any, Optional, Callable
+from dataclasses import dataclass, asdict
+from datetime import datetime
+import re
+
+@dataclass
+class RecordedRequest:
+    """Represents a recorded HTTP request."""
+    timestamp: str
+    method: str
+    path: str
+    headers: Dict[str, str]
+    body: Optional[Any]
+    response_status: int
+    response_headers: Dict[str, str]
+    response_body: Any
+    session_id: Optional[str] = None
+
+class RequestRecorder:
+    """Records real API interactions for later replay as mocks."""
+    
+    def __init__(self):
+        self.recorded_requests: List[RecordedRequest] = []
+        self.filters: List[Callable] = []
+        self.sensitive_patterns: List[str] = [
+            r'password',
+            r'token',
+            r'key',
+            r'secret',
+            r'auth'
+        ]
+    
+    def add_filter(self, filter_func: Callable):
+        """Add a custom filter function."""
+        self.filters.append(filter_func)
+    
+    def add_sensitive_pattern(self, pattern: str):
+        """Add a regex pattern for sensitive data."""
+        self.sensitive_patterns.append(pattern)
+    
+    def record_request(self, request: RecordedRequest) -> bool:
+        """Record a request if it passes all filters."""
+        if self._should_record(request):
+            self._sanitize_request(request)
+            self.recorded_requests.append(request)
+            return True
+        return False
+    
+    def _should_record(self, request: RecordedRequest) -> bool:
+        """Check if request should be recorded based on filters."""
+        for filter_func in self.filters:
+            if not filter_func(request):
+                return False
+        return True
+    
+    def _sanitize_request(self, request: RecordedRequest):
+        """Remove sensitive information from request."""
+        # Sanitize headers
+        sanitized_headers = {}
+        for key, value in request.headers.items():
+            if not self._is_sensitive(key):
+                sanitized_headers[key] = value
+            else:
+                sanitized_headers[key] = "[REDACTED]"
+        request.headers = sanitized_headers
+        
+        # Sanitize body if it's a string
+        if isinstance(request.body, str):
+            request.body = self._sanitize_string(request.body)
+        elif isinstance(request.body, dict):
+            request.body = self._sanitize_dict(request.body)
+    
+    def _is_sensitive(self, key: str) -> bool:
+        """Check if a key contains sensitive information."""
+        key_lower = key.lower()
+        return any(re.search(pattern, key_lower) for pattern in self.sensitive_patterns)
+    
+    def _sanitize_string(self, text: str) -> str:
+        """Sanitize sensitive data in a string."""
+        for pattern in self.sensitive_patterns:
+            text = re.sub(pattern, '[REDACTED]', text, flags=re.IGNORECASE)
+        return text
+    
+    def _sanitize_dict(self, data: Dict) -> Dict:
+        """Sanitize sensitive data in a dictionary."""
+        sanitized = {}
+        for key, value in data.items():
+            if self._is_sensitive(key):
+                sanitized[key] = '[REDACTED]'
+            elif isinstance(value, dict):
+                sanitized[key] = self._sanitize_dict(value)
+            elif isinstance(value, str):
+                sanitized[key] = self._sanitize_string(value)
+            else:
+                sanitized[key] = value
+        return sanitized
+    
+    def export_recording(self, file_path: str, format: str = 'json'):
+        """Export recorded requests to file."""
+        data = {
+            'recorded_at': datetime.now().isoformat(),
+            'requests': [asdict(req) for req in self.recorded_requests]
+        }
+        
+        with open(file_path, 'w') as f:
+            if format.lower() == 'json':
+                json.dump(data, f, indent=2)
+            else:
+                # Could add other formats like YAML, CSV, etc.
+                json.dump(data, f, indent=2)
+    
+    def load_recording(self, file_path: str):
+        """Load recorded requests from file."""
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        self.recorded_requests = [
+            RecordedRequest(**req_data) for req_data in data.get('requests', [])
+        ]
+    
+    def get_requests_by_path(self, path: str) -> List[RecordedRequest]:
+        """Get all recorded requests for a specific path."""
+        return [req for req in self.recorded_requests if req.path == path]
+    
+    def get_requests_by_method(self, method: str) -> List[RecordedRequest]:
+        """Get all recorded requests for a specific HTTP method."""
+        return [req for req in self.recorded_requests if req.method.upper() == method.upper()]
+
+class ProxyRecorder:
+    """Records requests by proxying them to real APIs."""
+    
+    def __init__(self, target_url: str):
+        self.target_url = target_url
+        self.recorder = RequestRecorder()
+        self.session_requests: Dict[str, List[RecordedRequest]] = {}
+    
+    def start_proxy_session(self, session_id: str):
+        """Start a new proxy recording session."""
+        self.session_requests[session_id] = []
+    
+    def record_proxy_request(self, session_id: str, request: RecordedRequest):
+        """Record a request during proxy session."""
+        if session_id in self.session_requests:
+            if self.recorder.record_request(request):
+                self.session_requests[session_id].append(request)
+    
+    def end_proxy_session(self, session_id: str) -> List[RecordedRequest]:
+        """End a proxy session and return recorded requests."""
+        return self.session_requests.get(session_id, [])
+    
+    def get_session_summary(self, session_id: str) -> Dict[str, Any]:
+        """Get summary statistics for a proxy session."""
+        requests = self.session_requests.get(session_id, [])
+        if not requests:
+            return {}
+        
+        methods = {}
+        paths = {}
+        status_codes = {}
+        
+        for req in requests:
+            methods[req.method] = methods.get(req.method, 0) + 1
+            paths[req.path] = paths.get(req.path, 0) + 1
+            status_codes[req.response_status] = status_codes.get(req.response_status, 0) + 1
+        
+        return {
+            'total_requests': len(requests),
+            'methods': methods,
+            'paths': paths,
+            'status_codes': status_codes,
+            'duration': self._calculate_session_duration(requests)
+        }
+    
+    def _calculate_session_duration(self, requests: List[RecordedRequest]) -> float:
+        """Calculate the duration of a proxy session."""
+        if len(requests) < 2:
+            return 0.0
+        
+        start_time = datetime.fromisoformat(requests[0].timestamp)
+        end_time = datetime.fromisoformat(requests[-1].timestamp)
+        return (end_time - start_time).total_seconds()
+
+class ReplayEngine:
+    """Replays recorded requests as mock responses."""
+    
+    def __init__(self):
+        self.recorded_responses: Dict[str, List[RecordedRequest]] = {}
+        self.response_variations: Dict[str, List[Any]] = {}
+    
+    def load_recorded_requests(self, requests: List[RecordedRequest]):
+        """Load recorded requests for replay."""
+        for request in requests:
+            key = f"{request.method}:{request.path}"
+            if key not in self.recorded_responses:
+                self.recorded_responses[key] = []
+            self.recorded_responses[key].append(request)
+    
+    def get_response(self, method: str, path: str) -> Optional[Dict[str, Any]]:
+        """Get a recorded response for the given method and path."""
+        key = f"{method}:{path}"
+        responses = self.recorded_responses.get(key, [])
+        
+        if not responses:
+            return None
+        
+        # Return the most recent response by default
+        response = responses[-1]
+        
+        return {
+            'status_code': response.response_status,
+            'headers': response.response_headers,
+            'body': response.response_body
+        }
+    
+    def get_response_variation(self, method: str, path: str) -> Optional[Dict[str, Any]]:
+        """Get a random variation of recorded responses."""
+        key = f"{method}:{path}"
+        responses = self.recorded_responses.get(key, [])
+        
+        if not responses:
+            return None
+        
+        # Return a random response
+        import random
+        response = random.choice(responses)
+        
+        return {
+            'status_code': response.response_status,
+            'headers': response.response_headers,
+            'body': response.response_body
+        }
+    
+    def generate_variations(self, method: str, path: str, count: int = 5):
+        """Generate variations of recorded responses for more realistic testing."""
+        key = f"{method}:{path}"
+        responses = self.recorded_responses.get(key, [])
+        
+        if not responses:
+            return
+        
+        variations = []
+        for _ in range(count):
+            # Create variations by modifying the response
+            base_response = responses[0]
+            variation = self._create_variation(base_response)
+            variations.append(variation)
+        
+        self.response_variations[key] = variations
+    
+    def _create_variation(self, base_response: RecordedRequest) -> Dict[str, Any]:
+        """Create a variation of a recorded response."""
+        # This is a simple variation - could be made more sophisticated
+        variation = {
+            'status_code': base_response.response_status,
+            'headers': base_response.response_headers.copy(),
+            'body': base_response.response_body
+        }
+        
+        # Add some random variation to the response
+        if isinstance(variation['body'], dict):
+            variation['body'] = variation['body'].copy()
+            # Could add random variations here
+        
+        return variation 

api_mocker/server.py

@@ -0,0 +1,96 @@
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import JSONResponse
+import uvicorn
+from typing import Optional, Dict, Any
+from .core import CoreEngine, RouteConfig
+from .config import ConfigLoader
+
+class MockServer:
+    def __init__(self, config_path: Optional[str] = None):
+        self.app = FastAPI(title="api-mocker")
+        self.config_path = config_path
+        self.engine = CoreEngine()
+        self.config = {}
+        
+        if config_path:
+            self.load_config(config_path)
+        
+        self._setup_routes()
+
+    def load_config(self, config_path: str):
+        """Load configuration from file."""
+        try:
+            self.config = ConfigLoader.load(config_path)
+            self._apply_config()
+        except Exception as e:
+            print(f"Warning: Failed to load config {config_path}: {e}")
+
+    def _apply_config(self):
+        """Apply configuration to the engine."""
+        routes_config = self.config.get("routes", [])
+        print(f"Loading {len(routes_config)} routes from config")
+        
+        for route_data in routes_config:
+            print(f"Adding route: {route_data['method']} {route_data['path']}")
+            # Create a response function from the config
+            response_config = route_data.get("response", {})
+            
+            def create_response_func(config):
+                def response_func(path: str, method: str, headers: Dict, body: Any, engine):
+                    return {
+                        "status_code": config.get("status_code", 200),
+                        "body": config.get("body", {}),
+                        "headers": config.get("headers", {})
+                    }
+                return response_func
+            
+            route = RouteConfig(
+                path=route_data["path"],
+                method=route_data["method"],
+                response=create_response_func(response_config),
+                status_code=response_config.get("status_code", 200),
+                headers=response_config.get("headers"),
+                delay=route_data.get("delay", 0),
+                dynamic=route_data.get("dynamic", False)
+            )
+            self.engine.router.add_route(route)
+        
+        print(f"Total routes loaded: {len(self.engine.router.routes)}")
+
+    def _setup_routes(self):
+        """Set up FastAPI routes using the core engine."""
+        
+        @self.app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"])
+        async def handle_request(request: Request, path: str):
+            # Get request details
+            method = request.method
+            headers = dict(request.headers)
+            body = None
+            
+            print(f"Received request: {method} /{path}")
+            
+            if method in ["POST", "PUT", "PATCH"]:
+                try:
+                    body = await request.json()
+                except:
+                    body = await request.body()
+            
+            # Process request through core engine
+            response = self.engine.process_request(path, method, headers, body)
+            
+            # Return response
+            status_code = response.get("status_code", 200)
+            response_body = response.get("body", {})
+            response_headers = response.get("headers", {})
+            
+            return JSONResponse(
+                content=response_body,
+                status_code=status_code,
+                headers=response_headers
+            )
+
+    def start(self, host: str = "127.0.0.1", port: int = 8000):
+        """Start the mock server."""
+        print(f"Starting api-mocker server on http://{host}:{port}")
+        print(f"Loaded {len(self.engine.router.routes)} routes")
+        uvicorn.run(self.app, host=host, port=port) 

api_mocker-0.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: api-mocker
+Version: 0.1.0
+Summary: The industry-standard, production-ready, free API mocking and development acceleration tool.
+Author-email: sherin joseph roy <sherin.joseph2217@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 sherin joseph roy
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE. 
+Project-URL: Homepage, https://github.com/Sherin-SEF-AI/api-mocker
+Project-URL: Repository, https://github.com/Sherin-SEF-AI/api-mocker.git
+Keywords: api,mock,mocking,development,testing,openapi,swagger,cli,devops
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.23.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: pytest>=7.0.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: rich>=13.0.0
+Dynamic: license-file
+
+# api-mocker
+
+The industry-standard, production-ready, free API mocking and development acceleration tool.
+
+## Project Mission
+Create the most comprehensive, user-friendly, and feature-rich API mocking solution to eliminate API dependency bottlenecks and accelerate development workflows for all developers.
+
+## Features
+- Robust HTTP mock server supporting all HTTP methods
+- Dynamic and static response generation
+- OpenAPI/Swagger/Postman import/export
+- CLI and Python API interfaces
+- Hot-reloading, config file support (JSON/YAML/TOML)
+- Request recording, replay, and proxy mode
+- Schema-based data generation and validation
+- Advanced routing, middleware, and authentication simulation
+- Data persistence, state management, and in-memory DB
+- Performance, monitoring, and analytics tools
+- Framework integrations (Django, Flask, FastAPI, Node.js, etc.)
+- Docker, CI/CD, and cloud deployment support
+- Team collaboration and plugin architecture
+
+## Installation
+```bash
+pip install api-mocker
+```
+
+## Quick Start
+```bash
+api-mocker start --config api-mock.yaml
+```
+Or use as a Python library:
+```python
+from api_mocker import MockServer
+server = MockServer(config_path="api-mock.yaml")
+server.start()
+```
+
+## Documentation
+See [Full Documentation](https://github.com/Sherin-SEF-AI/api-mocker#documentation) for guides, API reference, and examples.
+
+## Contributing
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+MIT License
+
+---
+© 2024 sherin joseph roy 

api_mocker-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+api_mocker/__init__.py,sha256=CFC641XJCw_2RbFocNHCTwfr3EEdOQmICFGG_Xlny3Y,168
+api_mocker/cli.py,sha256=LktBFt7V7c1Y00zwZuZzjD5ktAJsm31S7BAaiiGkg5g,19485
+api_mocker/config.py,sha256=zNlJCk1Bs0BrGU-92wiFv2ZTBRu9dJQ6sF8Dh6kIhLQ,913
+api_mocker/core.py,sha256=G04vhIcVzuoynZ4GVM6e222bnemMdXN4pOQuvalWY6c,8480
+api_mocker/openapi.py,sha256=Pb1gKbBWosEV5i739rW0Nb3ArNq62lgMN0ecyvigNKY,7403
+api_mocker/plugins.py,sha256=OK3OVHJszDky46JHntMVsZUH1ajBjBhAKq3TCDYuxWI,8178
+api_mocker/recorder.py,sha256=7tiT2Krxy3nLDxFAE7rpZSimuD-rKeiwdU72cp0dg6E,9984
+api_mocker/server.py,sha256=xfczRj4xFXGVaGn2pVPgGvYyv3IHUlYTEz3Hop1KQu0,3812
+api_mocker-0.1.0.dist-info/licenses/LICENSE,sha256=FzyeLcPe623lrwpFx3xQ3W0Hb_S2sbHqLzhSXaTmcGg,1074
+api_mocker-0.1.0.dist-info/METADATA,sha256=yrcm8uNXwtVs6jH8Tb9kj2VgW5EuekIopGZ4S7BkRxI,3901
+api_mocker-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+api_mocker-0.1.0.dist-info/entry_points.txt,sha256=dj0UIkQ36Uq3oeSjGzmRRUQKFriq4WMCzg7TCor7wkM,51
+api_mocker-0.1.0.dist-info/top_level.txt,sha256=ZcowEudKsJ6xbvOXIno2zZcPhjB-gGO1w7uzoUKRKDM,11
+api_mocker-0.1.0.dist-info/RECORD,,

api_mocker-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

api_mocker-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+api-mocker = api_mocker.cli:main

api_mocker-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 sherin joseph roy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

api_mocker-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+api_mocker