api-mocker 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

api_mocker/mock_responses.py

@@ -89,6 +89,7 @@ class MockAPIResponse:
     
     def matches_request(self, request_path: str, request_method: str, 
                        request_headers: Dict[str, str] = None,
+                       body: Any = None,
                        **kwargs) -> bool:
         """
         Check if this response matches the given request.
@@ -97,19 +98,21 @@ class MockAPIResponse:
             request_path: The request path
             request_method: The HTTP method
             request_headers: Request headers
-            request_body: Request body
+            body: Request body
             
         Returns:
             bool: True if response matches request
         """
+        # Handle case where body is passed in kwargs (for backward compatibility)
+        if body is None and 'request_body' in kwargs:
+            body = kwargs['request_body']
         # Basic path and method matching
         if not self._path_matches(request_path) or self.method.value != request_method:
             return False
         
         # Check conditions if any
         if self.conditions:
-            request_body = kwargs.get('body')
-            return self._check_conditions(request_headers, request_body)
+            return self._check_conditions(request_headers, body)
         
         return True
     
@@ -258,31 +261,21 @@ class MockAPIResponse:
     
     def _generate_templated_response(self, context: Dict[str, Any] = None) -> Any:
         """Generate templated response with variable substitution"""
-        if isinstance(self.body, dict):
-            # Handle dictionary body with template variables
-            result = {}
-            vars_dict = {**self.template_vars, **(context or {})}
-            
-            for key, value in self.body.items():
-                if isinstance(value, str):
-                    # Replace template variables in string values
-                    for var_key, var_value in vars_dict.items():
-                        value = value.replace(f'{{{{{var_key}}}}}', str(var_value))
-                result[key] = value
-            return result
-        elif isinstance(self.body, str):
-            template = self.body
-            vars_dict = {**self.template_vars, **(context or {})}
-            
-            for key, value in vars_dict.items():
-                template = template.replace(f'{{{{{key}}}}}', str(value))
-            
-            try:
-                return json.loads(template)
-            except json.JSONDecodeError:
-                return template
-        
-        return self.body
+        vars_dict = {**self.template_vars, **(context or {})}
+        return self._recursive_replace(self.body, vars_dict)
+
+    def _recursive_replace(self, obj: Any, vars_dict: Dict[str, Any]) -> Any:
+        """Recursively replace template variables in object"""
+        if isinstance(obj, dict):
+            return {k: self._recursive_replace(v, vars_dict) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [self._recursive_replace(item, vars_dict) for item in obj]
+        elif isinstance(obj, str):
+            for var_key, var_value in vars_dict.items():
+                obj = obj.replace(f'{{{{{var_key}}}}}', str(var_value))
+            return obj
+        else:
+            return obj
     
     def to_dict(self) -> Dict[str, Any]:
         """Convert response to dictionary for serialization"""

api_mocker/resources.py

@@ -0,0 +1,176 @@
+from typing import Dict, Any, List, Optional
+import math
+from .core import CoreEngine
+
+class ResourceHandler:
+    """
+    Generic handler for stateful REST resources.
+    Uses CoreEngine's StateManager for persistence.
+    """
+    
+    def __init__(self, resource_name: str, id_field: str = "id"):
+        self.resource_name = resource_name
+        self.id_field = id_field
+
+    def _get_collection(self, engine: CoreEngine) -> List[Dict]:
+        """Get the full collection from state manager."""
+        collection = engine.state_manager.get_data(self.resource_name)
+        if collection is None:
+            collection = []
+            engine.state_manager.set_data(self.resource_name, collection)
+        return collection
+
+    def _save_collection(self, engine: CoreEngine, collection: List[Dict]):
+        """Save the collection to state manager."""
+        engine.state_manager.set_data(self.resource_name, collection)
+
+    def list(self, path: str, method: str, headers: Dict, body: Any, engine: CoreEngine, query_params: Dict = None) -> Dict:
+        """
+        Handle GET /resource
+        Supports: search (q=), filtering (?field=value), pagination (page, limit), sorting (sort)
+        """
+        collection = self._get_collection(engine)
+        query_params = query_params or {}
+        
+        # 1. Filtering & Search
+        filtered = []
+        search_query = query_params.get('q')
+        
+        for item in collection:
+            matches = True
+            
+            # Simple Filter Matching
+            for key, value in query_params.items():
+                if key in ['page', 'limit', 'sort', 'q']:
+                    continue
+                if str(item.get(key, '')) != value:
+                    matches = False
+                    break
+            
+            # Search Query (naive text match across all string fields)
+            if matches and search_query:
+                text_match = False
+                for v in item.values():
+                    if isinstance(v, str) and search_query.lower() in v.lower():
+                        text_match = True
+                        break
+                if not text_match:
+                    matches = False
+            
+            if matches:
+                filtered.append(item)
+        
+        # 2. Sorting
+        sort_param = query_params.get('sort')
+        if sort_param:
+            reverse = False
+            if sort_param.endswith('_desc'):
+                key = sort_param[:-5]
+                reverse = True
+            elif sort_param.endswith('_asc'):
+                key = sort_param[:-4]
+            else:
+                key = sort_param
+            
+            # Basic sort ability
+            filtered.sort(key=lambda x: str(x.get(key, '')), reverse=reverse)
+
+        # 3. Pagination
+        page = int(query_params.get('page', 1))
+        limit = int(query_params.get('limit', 10))
+        total = len(filtered)
+        total_pages = math.ceil(total / limit)
+        
+        start = (page - 1) * limit
+        end = start + limit
+        paginated_items = filtered[start:end]
+        
+        return {
+            "status_code": 200,
+            "body": {
+                "data": paginated_items,
+                "meta": {
+                    "total": total,
+                    "page": page,
+                    "limit": limit,
+                    "total_pages": total_pages
+                }
+            }
+        }
+
+    def create(self, path: str, method: str, headers: Dict, body: Any, engine: CoreEngine, query_params: Dict = None) -> Dict:
+        """Handle POST /resource"""
+        collection = self._get_collection(engine)
+        
+        new_item = body if isinstance(body, dict) else {}
+        
+        # Auto-generate ID if missing
+        if self.id_field not in new_item:
+            new_id = engine.state_manager.get_next_id(self.resource_name)
+            new_item[self.id_field] = str(new_id) # Using string IDs for consistency
+        
+        import time
+        new_item['created_at'] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        
+        collection.append(new_item)
+        self._save_collection(engine, collection)
+        
+        return {
+            "status_code": 201,
+            "body": new_item
+        }
+
+    def get(self, path: str, method: str, headers: Dict, body: Any, engine: CoreEngine, query_params: Dict = None) -> Dict:
+        """Handle GET /resource/{id}"""
+        # We need to extract ID from the path.
+        # Since we don't have direct access to resolved path params here easily without hacky parsing of 'path',
+        # we rely on the router having done it.
+        # Caveat: CoreEngine doesn't pass path_params.
+        # Workaround: Re-parse the ID from the end of the path.
+        # Assumption: standard REST path /resource/{id}
+        
+        # Try to get from router params first if I updated CoreEngine? I didn't update CoreEngine to pass path_params.
+        # Let's just grab the last segment.
+        resource_id = path.rstrip('/').split('/')[-1]
+        
+        collection = self._get_collection(engine)
+        for item in collection:
+            if str(item.get(self.id_field)) == resource_id:
+                return {"status_code": 200, "body": item}
+        
+        return {"status_code": 404, "body": {"error": f"{self.resource_name} not found"}}
+
+    def update(self, path: str, method: str, headers: Dict, body: Any, engine: CoreEngine, query_params: Dict = None) -> Dict:
+        """Handle PUT/PATCH /resource/{id}"""
+        resource_id = path.rstrip('/').split('/')[-1]
+        collection = self._get_collection(engine)
+        
+        for i, item in enumerate(collection):
+            if str(item.get(self.id_field)) == resource_id:
+                # Merge updates
+                updated_item = item.copy()
+                if isinstance(body, dict):
+                    updated_item.update(body)
+                
+                # Protect ID ?? Usually yes, but this is a mock.
+                updated_item[self.id_field] = item[self.id_field] 
+                
+                collection[i] = updated_item
+                self._save_collection(engine, collection)
+                return {"status_code": 200, "body": updated_item}
+                
+        return {"status_code": 404, "body": {"error": f"{self.resource_name} not found"}}
+
+    def delete(self, path: str, method: str, headers: Dict, body: Any, engine: CoreEngine, query_params: Dict = None) -> Dict:
+        """Handle DELETE /resource/{id}"""
+        resource_id = path.rstrip('/').split('/')[-1]
+        collection = self._get_collection(engine)
+        
+        initial_len = len(collection)
+        collection = [item for item in collection if str(item.get(self.id_field)) != resource_id]
+        
+        if len(collection) < initial_len:
+            self._save_collection(engine, collection)
+            return {"status_code": 204, "body": None}
+            
+        return {"status_code": 404, "body": {"error": f"{self.resource_name} not found"}}

api_mocker/server.py

@@ -4,15 +4,23 @@ import uvicorn
 from typing import Optional, Dict, Any
 from .core import CoreEngine, RouteConfig
 from .config import ConfigLoader
+import logging
+
+logger = logging.getLogger(__name__)
 
 class MockServer:
-    def __init__(self, config_path: Optional[str] = None):
+    def __init__(self, config_path: Optional[str] = None, config_data: Optional[Dict[str, Any]] = None):
         self.app = FastAPI(title="api-mocker")
         self.config_path = config_path
         self.engine = CoreEngine()
         self.config = {}
         
-        if config_path:
+        logging.basicConfig(level=logging.INFO)
+        
+        if config_data:
+            self.config = config_data
+            self._apply_config()
+        elif config_path:
             self.load_config(config_path)
         
         self._setup_routes()
@@ -23,15 +31,15 @@ class MockServer:
             self.config = ConfigLoader.load(config_path)
             self._apply_config()
         except Exception as e:
-            print(f"Warning: Failed to load config {config_path}: {e}")
+            logger.error(f"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")
+        logger.info(f"Loading {len(routes_config)} routes from config")
         
         for route_data in routes_config:
-            print(f"Adding route: {route_data['method']} {route_data['path']}")
+            logger.info(f"Adding route: {route_data['method']} {route_data['path']}")
             # Create a response function from the config
             response_config = route_data.get("response", {})
             
@@ -51,12 +59,71 @@ class MockServer:
                 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)
+                dynamic=route_data.get("dynamic", False),
+                auth_required=route_data.get("auth", False)
             )
             self.engine.router.add_route(route)
         
         print(f"Total routes loaded: {len(self.engine.router.routes)}")
 
+        # Process resources
+        resources_config = self.config.get("resources", [])
+        print(f"Loading {len(resources_config)} resources from config")
+        
+        for res_config in resources_config:
+            name = res_config['name']
+            base_path = res_config['path']
+            id_field = res_config.get('id_field', 'id')
+            
+            print(f"Adding resource: {name} at {base_path}")
+            
+            # Import here to avoid circular imports
+            from .resources import ResourceHandler
+            handler = ResourceHandler(name, id_field)
+            
+            # Add standard CRUD routes
+            # LIST
+            self.engine.router.add_route(RouteConfig(
+                path=base_path, 
+                method="GET", 
+                response=handler.list,
+                delay=res_config.get('delay', 0)
+            ))
+            # CREATE
+            self.engine.router.add_route(RouteConfig(
+                path=base_path, 
+                method="POST", 
+                response=handler.create,
+                delay=res_config.get('delay', 0)
+            ))
+            # GET Item
+            self.engine.router.add_route(RouteConfig(
+                path=f"{base_path}/{{id}}", 
+                method="GET", 
+                response=handler.get,
+                delay=res_config.get('delay', 0)
+            ))
+            # UPDATE
+            self.engine.router.add_route(RouteConfig(
+                path=f"{base_path}/{{id}}", 
+                method="PUT", 
+                response=handler.update,
+                delay=res_config.get('delay', 0)
+            ))
+            self.engine.router.add_route(RouteConfig(
+                path=f"{base_path}/{{id}}", 
+                method="PATCH", 
+                response=handler.update,
+                delay=res_config.get('delay', 0)
+            ))
+            # DELETE
+            self.engine.router.add_route(RouteConfig(
+                path=f"{base_path}/{{id}}", 
+                method="DELETE", 
+                response=handler.delete,
+                delay=res_config.get('delay', 0)
+            ))
+
     def _setup_routes(self):
         """Set up FastAPI routes using the core engine."""
         
@@ -75,8 +142,11 @@ class MockServer:
                 except:
                     body = await request.body()
             
+            # Get query parameters
+            query_params = dict(request.query_params)
+            
             # Process request through core engine
-            response = self.engine.process_request(path, method, headers, body)
+            response = self.engine.process_request(path, method, headers, body, query_params)
             
             # Return response
             status_code = response.get("status_code", 200)