Refactored METHOD and JSON validators

Author: Veinar

dracan/validators/json_validator.py

@@ -3,43 +3,49 @@
 
 def validate_json(data, schema):
     """
-    Validate the given JSON data against the provided schema.
+    Validate the given JSON data against the provided schema, including required fields.
     
     :param data: The JSON data to validate.
-    :param schema: The schema to validate against.
+    :param schema: The schema to validate against, which includes 'required' fields.
     :return: Tuple (is_valid, error_message).
     """
     try:
+        # Validate the data against the schema, which includes required fields
         validate(instance=data, schema=schema)
         return True, None
     except ValidationError as e:
+        # Return False and a clear error message if validation fails
         return False, str(e)
 
-
 def create_json_validator(rules_config):
     """
     Creates a function that validates the request JSON based on the provided rules_config.
     
-    :param rules_config: The configuration that contains validation rules.
-    :return: A validation function or None if validation is disabled.
+    :param rules_config: The configuration that contains JSON validation rules, including the JSON schema.
+    :return: A validation function or None if JSON validation is disabled.
     """
-    validation_enabled = rules_config.get("validation_enabled", False)
+    json_validation_enabled = rules_config.get("json_validation_enabled", False) 
     json_schema = rules_config.get("json_schema", {})
-    
-    def validate_request():
+    detailed_errors_enabled = rules_config.get("detailed_errors_enabled", False)  # Default to False
+
+    def validate_json_request():
         """
-        Validates the request JSON against the schema if validation is enabled.
+        Validates the request JSON against the schema if JSON validation is enabled.
         :return: Tuple (is_valid, response) - is_valid is True if valid, False otherwise.
         """
-        if validation_enabled and request.method in ['POST', 'PUT']:
-            is_valid, error_message = validate_json(request.get_json(), json_schema)
+        if json_validation_enabled and request.method in ['POST', 'PUT']:
+            data = request.get_json()
+            is_valid, error_message = validate_json(data, json_schema)
             if not is_valid:
-                return False, jsonify({'error': f"Invalid JSON: {error_message}"}), 400
+                # Determine whether to include detailed error information
+                error_message_to_display = error_message if detailed_errors_enabled else "Invalid JSON format"
+                # Return False and a 400 Bad Request response with only two values
+                return False, (jsonify({'error': f"{error_message_to_display}"}), 400)
         return True, None
 
-    if validation_enabled:
+    if json_validation_enabled:
         print("JSON validation is enabled")
     else:
         print("JSON validation is disabled")
 
-    return validate_request
+    return validate_json_request

dracan/validators/method_validator.py

@@ -4,18 +4,32 @@ def create_method_validator(rules_config):
     """
     Creates a function that validates if the request method is allowed based on the provided rules_config.
     
-    :param rules_config: The configuration that contains allowed methods.
+    :param rules_config: The configuration that contains allowed methods and whether method validation is enabled.
     :return: A validation function for HTTP methods.
     """
-    allowed_methods = rules_config.get("allowed_methods", ["GET", "POST", "PUT", "DELETE"])
+    allowed_methods = rules_config.get("allowed_methods", ["GET", "PUT", "POST", "DELETE"])
+    method_validation_enabled = rules_config.get("method_validation_enabled", False)  # Default to False
 
-    def validate_method():
+    def validate_http_method():
         """
-        Validates the request method against the allowed methods.
+        Validates the request method against the allowed methods if method validation is enabled.
         :return: Tuple (is_valid, response) - is_valid is True if valid, False otherwise.
         """
+        if not method_validation_enabled:
+            # If method validation is disabled, always return True
+            return True, None
+
         if request.method not in allowed_methods:
-            return False, jsonify({'error': f"Method {request.method} not allowed"}), 405
+            # Return False and a validation response with a 405 status code if method is not allowed
+            return False, (jsonify({'error': f"Method {request.method} not allowed"}), 405)
+        
+        # Return True and None if the method is allowed
         return True, None
 
-    return validate_method
+    if method_validation_enabled:
+        print("HTTP Method validation is enabled, allowed methods: " + " | ".join(allowed_methods))
+    else:
+        print("HTTP Method validation is disabled")
+
+
+    return validate_http_method

proxy_config.json

@@ -2,6 +2,6 @@
     "destination": {
         "host": "127.0.0.1",
         "port": 8080,
-        "path": "/health"
+        "path": "/"
     }
 }

rules_config.json

@@ -1,8 +1,9 @@
 {
     "limiting_enabled": true,
     "rate_limit": "10 per minute",
-    "allowed_methods": ["GET", "POST"],
+    "allowed_methods": ["GET", "POST", "DELETE"],
     "validation_enabled": true,
+    "detailed_errors_enabled": false,
     "json_schema": {
         "type": "object",
         "properties": {
@@ -11,4 +12,4 @@
         },
         "required": ["name", "age"]
     }
-}
+}