12 | Increase test coverage for InputFilter

Author: LeanderCS

CHAGELOG.md

@@ -9,7 +9,8 @@ All notable changes to this project will be documented in this file.
 
 - Workflow to run tests on all supported python versions. [Check it out](.github/workflows/test_env.yaml)
 - Added more test coverage for validators and filters.
-- Added tracking of coverage in tests.
+- Added tracking of coverage in tests. [Check it out](https://coveralls.io/github/LeanderCS/flask-inputfilter)
+- New functionality for global filters and validators in InputFilters.
 
 ### Validator
 

flask_inputfilter/InputFilter.py

@@ -82,9 +82,6 @@ def _applyFilters(self, field_name: str, value: Any) -> Any:
 
         field = self.fields.get(field_name)
 
-        if not field:
-            return value
-
         for filter_ in field["filters"]:
             value = filter_.apply(value)
 
@@ -100,9 +97,6 @@ def _validateField(self, field_name: str, value: Any) -> None:
 
         field = self.fields.get(field_name)
 
-        if not field:
-            return
-
         for validator in field["validators"]:
             validator.validate(value)
 

test/test_input_filter.py

@@ -1,6 +1,8 @@
 import unittest
 from unittest.mock import Mock, patch
 
+from flask import Flask, g, jsonify
+
 from flask_inputfilter import InputFilter
 from flask_inputfilter.Condition import BaseCondition
 from flask_inputfilter.Exception import ValidationError
@@ -23,6 +25,50 @@ def setUp(self) -> None:
 
         self.inputFilter = InputFilter()
 
+    @patch("flask_inputfilter.InputFilter.validateData")
+    def test_validate_decorator(self, mock_validate_data) -> None:
+        mock_validate_data.return_value = {"username": "test_user", "age": 25}
+
+        app = Flask(__name__)
+
+        class MyInputFilter(InputFilter):
+            def __init__(self):
+                super().__init__()
+                self.add(
+                    name="username",
+                    required=True,
+                    filters=[],
+                    validators=[],
+                )
+                self.add(
+                    name="age",
+                    required=False,
+                    default=18,
+                    filters=[],
+                    validators=[],
+                )
+
+        @app.route("/test", methods=["GET", "POST"])
+        @MyInputFilter.validate()
+        def test_route():
+            validated_data = g.validated_data
+            return jsonify(validated_data)
+
+        with app.test_client() as client:
+            response = client.get(
+                "/test", query_string={"username": "test_user"}
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(
+                response.json, {"username": "test_user", "age": 25}
+            )
+
+            response = client.post("/test", json={"username": "test_user"})
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(
+                response.json, {"username": "test_user", "age": 25}
+            )
+
     def test_optional(self) -> None:
         """
         Test that optional field validation works.
@@ -60,24 +106,47 @@ def test_fallback(self) -> None:
         self.inputFilter.add("available", required=True, fallback=True)
         self.inputFilter.add(
             "color",
+            required=True,
             fallback="red",
             validators=[InArrayValidator(["red", "green", "blue"])],
         )
 
-        # Fallback case triggert
         validated_data = self.inputFilter.validateData({"color": "yellow"})
 
         self.assertEqual(validated_data["available"], True)
         self.assertEqual(validated_data["color"], "red")
 
-        # Override fallback case
         validated_data = self.inputFilter.validateData(
             {"available": False, "color": "green"}
         )
 
         self.assertEqual(validated_data["available"], False)
         self.assertEqual(validated_data["color"], "green")
 
+    def test_fallback_with_default(self) -> None:
+        """
+        Test that fallback field works.
+        """
+
+        self.inputFilter.add(
+            "available", required=True, default=True, fallback=False
+        )
+        self.inputFilter.add(
+            "color",
+            default="red",
+            fallback="blue",
+            validators=[InArrayValidator(["red", "green", "blue"])],
+        )
+
+        validated_data = self.inputFilter.validateData({})
+
+        self.assertEqual(validated_data["available"], True)
+        self.assertEqual(validated_data["color"], "red")
+
+        validated_data = self.inputFilter.validateData({"available": False})
+
+        self.assertEqual(validated_data["available"], False)
+
     @patch("requests.request")
     def test_external_api(self, mock_request: Mock) -> None:
         """
@@ -127,26 +196,23 @@ def test_external_api_params(self, mock_request: Mock) -> None:
         mock_response.json.return_value = {"is_valid": True}
         mock_request.return_value = mock_response
 
-        # Add fields where the external API receives its values
         self.inputFilter.add("name")
 
         self.inputFilter.add("hash")
 
-        # Add a field with external API configuration
         self.inputFilter.add(
             "is_valid",
             required=True,
             external_api=ExternalApiConfig(
                 url="https://api.example.com/validate_user/{{name}}",
                 method="GET",
-                params={"hash": "{{hash}}"},
+                params={"hash": "{{hash}}", "id": 123},
                 data_key="is_valid",
                 headers={"custom_header": "value"},
                 api_key="1234",
             ),
         )
 
-        # API returns valid result
         validated_data = self.inputFilter.validateData(
             {"name": "test_user", "hash": "1234"}
         )
@@ -157,18 +223,16 @@ def test_external_api_params(self, mock_request: Mock) -> None:
             headers={"Authorization": "Bearer 1234", "custom_header": "value"},
             method="GET",
             url=expected_url,
-            params={"hash": "1234"},
+            params={"hash": "1234", "id": 123},
         )
 
-        # API returns invalid status code
         mock_response.status_code = 500
         mock_response.json.return_value = {"is_valid": False}
         with self.assertRaises(ValidationError):
             self.inputFilter.validateData(
                 {"name": "invalid_user", "hash": "1234"}
             )
 
-        # API returns invalid result
         mock_response.json.return_value = {}
         with self.assertRaises(ValidationError):
             self.inputFilter.validateData(
@@ -182,10 +246,62 @@ def test_external_api_fallback(self, mock_request: Mock) -> None:
         mock_response.json.return_value = {"name": True}
         mock_request.return_value = mock_response
 
+        self.inputFilter.add(
+            "username_with_fallback",
+            required=True,
+            fallback="fallback_user",
+            external_api=ExternalApiConfig(
+                url="https://api.example.com/validate_user",
+                method="GET",
+                params={"user": "{{value}}"},
+                data_key="name",
+            ),
+        )
+
+        validated_data = self.inputFilter.validateData(
+            {"username_with_fallback": None}
+        )
+        self.assertEqual(
+            validated_data["username_with_fallback"], "fallback_user"
+        )
+
+    @patch("requests.request")
+    def test_external_api_default(self, mock_request: Mock) -> None:
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {}
+        mock_request.return_value = mock_response
+
         # API call with fallback
+        self.inputFilter.add(
+            "username_with_default",
+            default="default_user",
+            external_api=ExternalApiConfig(
+                url="https://api.example.com/validate_user",
+                method="GET",
+                params={"user": "{{value}}"},
+                data_key="name",
+            ),
+        )
+
+        validated_data = self.inputFilter.validateData({})
+        self.assertEqual(
+            validated_data["username_with_default"], "default_user"
+        )
+
+    @patch("requests.request")
+    def test_external_api_fallback_with_default(
+        self, mock_request: Mock
+    ) -> None:
+        mock_response = Mock()
+        mock_response.status_code = 400
+        mock_response.json.return_value = {"name": True}
+        mock_request.return_value = mock_response
+
         self.inputFilter.add(
             "username_with_fallback",
             required=True,
+            default="default_user",
             fallback="fallback_user",
             external_api=ExternalApiConfig(
                 url="https://api.example.com/validate_user",
@@ -202,6 +318,50 @@ def test_external_api_fallback(self, mock_request: Mock) -> None:
             validated_data["username_with_fallback"], "fallback_user"
         )
 
+    @patch("requests.request")
+    def test_external_invalid_api_response(self, mock_request: Mock) -> None:
+        """
+        Test that a non-JSON API response raises a ValidationError.
+        """
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.side_effect = ValueError("Invalid JSON")
+        mock_request.return_value = mock_response
+
+        self.inputFilter.add(
+            "is_valid",
+            external_api=ExternalApiConfig(
+                url="https://api.example.com/validate",
+                method="GET",
+            ),
+        )
+
+        with self.assertRaises(ValidationError):
+            self.inputFilter.validateData({})
+
+    @patch("requests.request")
+    def test_external_api_response_with_no_data_key(
+        self, mock_request: Mock
+    ) -> None:
+        """
+        Test that an API response with no data key raises a ValidationError.
+        """
+        mock_response = Mock()
+        mock_response.status_code = 400
+        mock_response.json.return_value = {}
+        mock_request.return_value = mock_response
+
+        self.inputFilter.add(
+            "is_valid",
+            external_api=ExternalApiConfig(
+                url="https://api.example.com/validate",
+                method="GET",
+            ),
+        )
+
+        with self.assertRaises(ValidationError):
+            self.inputFilter.validateData({})
+
     def test_multiple_validators(self) -> None:
         """
         Test that multiple validators are applied correctly.
@@ -241,27 +401,6 @@ def check(self, data: dict) -> bool:
         with self.assertRaises(ValidationError):
             self.inputFilter.validateData({"age": 17})
 
-    @patch("requests.request")
-    def test_invalid_api_response(self, mock_request: Mock) -> None:
-        """
-        Test that a non-JSON API response raises a ValidationError.
-        """
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.side_effect = ValueError("Invalid JSON")
-        mock_request.return_value = mock_response
-
-        self.inputFilter.add(
-            "is_valid",
-            external_api=ExternalApiConfig(
-                url="https://api.example.com/validate",
-                method="GET",
-            ),
-        )
-
-        with self.assertRaises(ValidationError):
-            self.inputFilter.validateData({})
-
     def test_global_filter_applied_to_all_fields(self) -> None:
         self.inputFilter.add("field1")
         self.inputFilter.add("field2")