Implement tests for JSON Schema on list and dict types in the Json parameter type

Author: smt5541

flask_parameter_validation/test/test_json_params.py

@@ -881,3 +881,109 @@ def test_max_list_length(client):
     # Test that above length yields error
     r = client.post(url, json={"v": ["the", "longest", "of", "lists"]})
     assert "error" in r.json
+
+
+def test_list_json_schema(client):
+    url = "/json/list/json_schema"
+    # Test that passing schema validation yields input
+    v = [{"user_id": 1, "first_name": "John", "last_name": "Doe", "tags": ["test_account"]}]
+    r = client.post(url, json={"v": v})
+    assert type(r.json["v"]) is list
+    assert len(r.json["v"]) == 1
+    assert type(r.json["v"][0]) is dict
+    assert v[0] == r.json["v"][0]
+    # Test that failing schema validation yields error
+    v = [{"user_id": 1, "first_name": "John", "last_name": "Doe"}]
+    r = client.post(url, json={"v": v})
+    assert "error" in r.json
+
+
+def test_required_dict(client):
+    url = "/json/dict/required"
+    # Test that dict yields input
+    v = {"a": "b"}
+    r = client.post(url, json={"v": v})
+    assert "v" in r.json
+    assert type(r.json["v"]) is dict
+    assert v == r.json["v"]
+    # Test that non-dict yields error
+    r = client.post(url, json={"v": "a"})
+    assert "error" in r.json
+
+
+def test_optional_dict(client):
+    url = "/json/dict/optional"
+    # Test that dict yields input
+    v = {"a": "b"}
+    r = client.post(url, json={"v": v})
+    assert "v" in r.json
+    assert type(r.json["v"]) is dict
+    assert v == r.json["v"]
+    # Test that non-dict yields error
+    r = client.post(url, json={"v": "a"})
+    assert "error" in r.json
+    # Test that no input yields None
+    r = client.post(url)
+    assert "v" in r.json
+    assert r.json["v"] is None
+
+
+def test_dict_default(client):
+    url = "/json/dict/default"
+    # Test that present dict yields input values
+    n_opt = {"e": "f"}
+    opt = {"g": "h"}
+    r = client.post(url, json={"n_opt": n_opt, "opt": opt})
+    assert "n_opt" in r.json
+    assert "opt" in r.json
+    assert type(r.json["n_opt"]) is dict
+    assert type(r.json["opt"]) is dict
+    assert n_opt == r.json["n_opt"]
+    assert opt == r.json["opt"]
+    # Test that missing dict yields default values
+    n_opt = {"a": "b"}
+    opt = {"c": "d"}
+    r = client.post(url)
+    assert "n_opt" in r.json
+    assert "opt" in r.json
+    assert type(r.json["n_opt"]) is dict
+    assert type(r.json["opt"]) is dict
+    assert n_opt == r.json["n_opt"]
+    assert opt == r.json["opt"]
+
+
+def test_dict_func(client):
+    url = "/json/dict/func"
+    # Test that dict passing func yields input value
+    v = {"a": "b", "c": "d"}
+    r = client.post(url, json={"v": v})
+    assert "v" in r.json
+    assert type(r.json["v"]) is dict
+    assert v == r.json["v"]
+    # Test that dict failing func yields error
+    v = {"A": "B", "C": "D"}
+    r = client.post(url, json={"v": v})
+    assert "error" in r.json
+
+
+def test_dict_json_schema(client):
+    url = "/json/dict/json_schema"
+    # Test that dict passing schema yields input value
+    v = {
+        "user_id": 1,
+        "first_name": "John",
+        "last_name": "Doe",
+        "tags": []
+    }
+    r = client.post(url, json={"v": v})
+    assert "v" in r.json
+    assert type(r.json["v"]) is dict
+    assert v == r.json["v"]
+    # Test that dict failing schema yields error
+    v = {
+        "user_id": 1,
+        "first_name": "John",
+        "last_name": "Doe"
+    }
+    r = client.post(url, json={"v": v})
+    assert "error" in r.json

flask_parameter_validation/test/testing_blueprints/dict_blueprint.py

@@ -0,0 +1,71 @@
+import datetime
+from typing import Optional, List, Union
+
+from flask import Blueprint, jsonify
+
+from flask_parameter_validation import ValidateParameters, Route
+from flask_parameter_validation.parameter_types.parameter import Parameter
+
+
+def get_dict_blueprint(ParamType: type[Parameter], bp_name: str, http_verb: str) -> Blueprint:
+    dict_bp = Blueprint(bp_name, __name__, url_prefix="/dict")
+    decorator = getattr(dict_bp, http_verb)
+
+    # dict not currently supported by Route
+    # def path(base: str, route_additions: str) -> str:
+    #     return base + (route_additions if ParamType is Route else "")
+
+    @decorator("/required")
+    @ValidateParameters()
+    def req_str(v: dict = ParamType()):
+        assert type(v) is dict
+        return jsonify({"v": v})
+
+    @decorator("/optional")
+    @ValidateParameters()
+    def optional(v: Optional[dict] = ParamType()):
+        return jsonify({"v": v})
+
+    @decorator("/default")
+    @ValidateParameters()
+    def default(
+            n_opt: dict = ParamType(default={"a": "b"}),
+            opt: dict = ParamType(default={"c": "d"})
+    ):
+        return jsonify({
+            "n_opt": n_opt,
+            "opt": opt
+        })
+
+    def are_keys_lowercase(v):
+        assert type(v) is dict
+        for key in v.keys():
+            if not key.islower():
+                return False
+        return True
+
+    @decorator("/func")
+    @ValidateParameters()
+    def func(v: dict = ParamType(func=are_keys_lowercase)):
+        return jsonify({"v": v})
+
+    json_schema = {
+        "type": "object",
+        "required": ["user_id", "first_name", "last_name", "tags"],
+        "properties": {
+            "user_id": {"type": "integer"},
+            "first_name": {"type": "string"},
+            "last_name": {"type": "string"},
+            "tags": {
+                "type": "array",
+                "items": {"type": "string"}
+            }
+        }
+    }
+
+    @decorator("/json_schema")
+    @ValidateParameters()
+    def json_schema(v: dict = ParamType(json_schema=json_schema)):
+        return jsonify({"v": v})
+
+    return dict_bp

flask_parameter_validation/test/testing_blueprints/list_blueprint.py

@@ -104,4 +104,26 @@ def min_list_length(v: List[str] = ParamType(min_list_length=3)):
     def max_list_length(v: List[str] = ParamType(max_list_length=3)):
         return jsonify({"v": v})
 
+    json_schema = {
+        "type": "array",
+        "items": {
+            "type": "object",
+            "required": ["user_id", "first_name", "last_name", "tags"],
+            "properties": {
+                "user_id": {"type": "integer"},
+                "first_name": {"type": "string"},
+                "last_name": {"type": "string"},
+                "tags": {
+                    "type": "array",
+                    "items": {"type": "string"}
+                }
+            }
+        }
+    }
+
+    @decorator("/json_schema")
+    @ValidateParameters()
+    def json_schema(v: list = ParamType(json_schema=json_schema)):
+        return jsonify({"v": v})
+
     return list_bp

flask_parameter_validation/test/testing_blueprints/parameter_blueprint.py

@@ -4,6 +4,7 @@
 from flask_parameter_validation.test.testing_blueprints.bool_blueprint import get_bool_blueprint
 from flask_parameter_validation.test.testing_blueprints.date_blueprint import get_date_blueprint
 from flask_parameter_validation.test.testing_blueprints.datetime_blueprint import get_datetime_blueprint
+from flask_parameter_validation.test.testing_blueprints.dict_blueprint import get_dict_blueprint
 from flask_parameter_validation.test.testing_blueprints.float_blueprint import get_float_blueprint
 from flask_parameter_validation.test.testing_blueprints.int_blueprint import get_int_blueprint
 from flask_parameter_validation.test.testing_blueprints.list_blueprint import get_list_blueprint
@@ -25,4 +26,5 @@ def get_parameter_blueprint(ParamType: type[Parameter], bp_name: str, param_name
     param_bp.register_blueprint(get_datetime_blueprint(ParamType, f"{bp_name}_datetime", http_verb))
     param_bp.register_blueprint(get_date_blueprint(ParamType, f"{bp_name}_date", http_verb))
     param_bp.register_blueprint(get_time_blueprint(ParamType, f"{bp_name}_time", http_verb))
+    param_bp.register_blueprint(get_dict_blueprint(ParamType, f"{bp_name}_dict", http_verb))
     return param_bp