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

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)