Implement JSON Schema validation for dict and list types

Author: smt5541

.github/workflows/python-test.yml

@@ -0,0 +1,35 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Flask-Parameter-Validation Unit Tests
+
+on:
+  push:
+    branches: [ "master", "github-ci" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.x"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pytest
+        cd flask_parameter_validation/test
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Test with Pytest
+      run: |
+        cd flask_parameter_validation
+        pytest

flask_parameter_validation/parameter_types/file.py

@@ -3,6 +3,10 @@
     - Would originally be in Flask's request.file
     - Value will be a FileStorage object
 """
+import io
+
+from werkzeug.datastructures import FileStorage
+
 from .parameter import Parameter
 
 
@@ -21,7 +25,7 @@ def __init__(
         self.min_length = min_length
         self.max_length = max_length
 
-    def validate(self, value):
+    def validate(self, value: FileStorage):
         # Content type validation
         if self.content_types is not None:
             # We check mimetype, as it strips charset etc.
@@ -31,15 +35,19 @@ def validate(self, value):
 
         # Min content length validation
         if self.min_length is not None:
-            if value.content_length < self.min_length:
+            origin = value.stream.tell()
+            if value.stream.seek(0, io.SEEK_END) < self.min_length:
                 raise ValueError(
                     f"must have a content-length at least {self.min_length}."
                 )
+            value.stream.seek(origin)
 
         # Max content length validation
         if self.max_length is not None:
-            if value.content_length > self.max_length:
+            origin = value.stream.tell()
+            if value.stream.seek(0, io.SEEK_END) > self.max_length:
                 raise ValueError(
                     f"must have a content-length at most {self.max_length}."
                 )
+            value.stream.seek(origin)
         return True

flask_parameter_validation/parameter_types/parameter.py

@@ -48,9 +48,28 @@ def __init__(
         self.alias = alias
         self.json_schema = json_schema
 
+    def func_helper(self, v):
+        func_result = self.func(v)
+        if type(func_result) is bool:
+            if not func_result:
+                raise ValueError(
+                    "value does not match the validator function."
+                )
+        elif type(func_result) is tuple:
+            if len(func_result) == 2 and type(func_result[0]) is bool and type(func_result[1]) is str:
+                if not func_result[0]:
+                    raise ValueError(
+                        func_result[1]
+                    )
+            else:
+                raise ValueError(
+                    f"validator function returned incorrect type: {str(type(func_result))}, should return bool or (bool, str)"
+                )
+
     # Validator
     def validate(self, value):
         print(f"Parameter#validate received {type(value)}")
+        original_value_type_list = type(value) is list
         if type(value) is list:
             values = value
             # Min list len
@@ -65,6 +84,8 @@ def validate(self, value):
                     raise ValueError(
                         f"must have have a maximum of {self.max_list_length} items."
                     )
+            if self.func is not None:
+                self.func_helper(value)
             if self.json_schema is not None:
                 try:
                     jsonschema.validate(value, self.json_schema)
@@ -87,7 +108,7 @@ def validate(self, value):
         for value in values:
             # Min length
             if self.min_str_length is not None:
-                if hasattr(value, "len") and len(value) < self.min_str_length:
+                if len(value) < self.min_str_length:
                     raise ValueError(
                         f"must have at least {self.min_str_length} characters."
                     )
@@ -131,24 +152,11 @@ def validate(self, value):
                         f"pattern does not match: {self.pattern}."
                     )
 
-            # Callable
-            if self.func is not None:
-                func_result = self.func(value)
-                if type(func_result) is bool:
-                    if not func_result:
-                        raise ValueError(
-                            "value does not match the validator function."
-                        )
-                elif type(func_result) is tuple:
-                    if len(func_result) == 2 and type(func_result[0]) is bool and type(func_result[1]) is str:
-                        if not func_result[0]:
-                            raise ValueError(
-                                func_result[1]
-                            )
-                    else:
-                        raise ValueError(
-                            f"validator function returned incorrect type: {str(type(func_result))}, should return bool or (bool, str)"
-                        )
+            # Callable (non-list)
+            if self.func is not None and not original_value_type_list:
+                self.func_helper(value)
+
+
 
         return True
 

flask_parameter_validation/parameter_types/query.py

@@ -31,11 +31,13 @@ def convert(self, value, allowed_types):
                     pass
             # bool conversion
             if bool in allowed_types:
-                if value.lower() == "true":
-                    value = True
-                elif value.lower() == "false":
-                    value = False
-            # dict conversion
+                try:
+                    if value.lower() == "true":
+                        value = True
+                    elif value.lower() == "false":
+                        value = False
+                except AttributeError:
+                    pass
             if dict in allowed_types:
                 try:
                     value = json.loads(value)

flask_parameter_validation/parameter_types/route.py

@@ -10,3 +10,30 @@ class Route(Parameter):
 
     def __init__(self, default=None, **kwargs):
         super().__init__(default, **kwargs)
+
+    def convert(self, value, allowed_types):
+        """Convert query parameters to corresponding types."""
+        if type(value) is str:
+            # int conversion
+            if int in allowed_types:
+                try:
+                    value = int(value)
+                except ValueError:
+                    pass
+            # float conversion
+            if float in allowed_types:
+                try:
+                    value = float(value)
+                except ValueError:
+                    pass
+            # bool conversion
+            if bool in allowed_types:
+                try:
+                    if value.lower() == "true":
+                        value = True
+                    elif value.lower() == "false":
+                        value = False
+                except AttributeError:
+                    pass
+
+        return super().convert(value, allowed_types)

flask_parameter_validation/parameter_validation.py

@@ -236,19 +236,14 @@ def validate(self, expected_input, all_request_inputs):
                 original_expected_input_type,
             )
 
-        print(json.dumps(user_input))
-
-        if expected_input_type_str.startswith("typing.List"):
-            # Validate parameter-specific requirements are met
-            try:
+        # Validate parameter-specific requirements are met
+        try:
+            if type(user_input) is list:
                 expected_delivery_type.validate(user_input)
-            except ValueError as e:
-                raise ValidationError(str(e), expected_name, expected_input_type)
-        else:
-            try:
+            else:
                 expected_delivery_type.validate(user_inputs[0])
-            except ValueError as e:
-                raise ValidationError(str(e), expected_name, expected_input_type)
+        except ValueError as e:
+            raise ValidationError(str(e), expected_name, expected_input_type)
 
         # Return input back to parent function
         if expected_input_type_str.startswith("typing.List"):

flask_parameter_validation/test/__init__.py

@@ -0,0 +1,19 @@
+import pytest
+from .testing_application import create_app
+
+
+@pytest.fixture(scope="session")
+def app():
+    app = create_app()
+    app.config.update({"TESTING": True})
+    yield app
+
+
+@pytest.fixture()
+def client(app):
+    return app.test_client()
+
+
+@pytest.fixture()
+def runner(app):
+    return app.test_cli_runner()

flask_parameter_validation/test/conftest.py

@@ -0,0 +1,3 @@
+Flask==3.0.2
+../../
+requests