Add support for pydantic and dataclasses

Author: Fabien Coelho

FlaskTester.py

@@ -9,7 +9,9 @@
 from typing import Any
 import importlib
 import logging
-import pytest
+import pytest  # for explicit fail calls, see _pytestFail
+import json
+import dataclasses
 
 log = logging.getLogger("flask_tester")
 
@@ -346,17 +348,56 @@ def request(self, method: str, path: str, status: int|None = None, content: str|
             cookies.update(kwargs["cookies"])
             del kwargs["cookies"]
 
+        # FIXME allow or forbid?
+        # if "json" in kwargs and "data" in kwargs:
+        #     log.warning("mix of json and data parameters in request")
+
+        # convert json parameters
+        if "json" in kwargs:
+            json_param = kwargs["json"]
+            assert isinstance(json_param, dict)
+            for name in list(json_param.keys()):
+                val = json_param[name]
+                if val is None:
+                    pass
+                elif isinstance(val, (bool, int, float, str, tuple, list, dict)):
+                    pass
+                elif "model_dump" in val.__dir__() and callable(val.model_dump):
+                    # probably pydantic
+                    json_param[name] = val.model_dump()
+                else: # pydantic or standard dataclasses?
+                    json_param[name] = dataclasses.asdict(val)
+
+        # convert data parameters
+        if "data" in kwargs:
+            data_param = kwargs["data"]
+            assert isinstance(data_param, dict)
+            for name in list(data_param.keys()):
+                val = data_param[name]
+                if val is None:
+                    data_param[name] = "null"
+                elif isinstance(val, (io.IOBase, tuple)):
+                    pass  # file parameters?
+                elif isinstance(val, (bool, int, float, str, list, dict)):
+                    data_param[name] = json.dumps(val)
+                elif "model_dump_json" in val.__dir__() and callable(val.model_dump_json):
+                    data_param[name] = val.model_dump_json()
+                else:
+                    data_param[name] = json.dumps(dataclasses.asdict(val))
+
         self._auth.setAuth(login, kwargs, cookies, auth=auth)
         res = self._request(method, path, cookies, **kwargs)  # type: ignore
 
         # check status
         if status is not None:
             if res.status_code != status:  # show error before aborting
+                # FIXME what if the useful part is at the end?
                 _pytestFail(f"bad {status} result: {res.status_code} {res.text[:512]}...")
 
         # check content
         if content is not None:
             if not re.search(content, res.text, re.DOTALL):
+                # FIXME what if the useful part is at the end?
                 _pytestFail(f"cannot find {content} in {res.text[:512]}...")
 
         return res

docs/documentation.md

@@ -86,6 +86,9 @@ The package provides two fixtures:
 
     The authentication data, here a password, must have been provided to the authenticator.
 
+    Direct parameters from `pydantic` and `dataclass` classes are supported and
+    converted to JSON.
+
   - `get post put patch delete` methods with the same extensions.
 
     Submit a `GET` request to path `/stats` authenticated as _hobbes_,

docs/versions.md

@@ -7,7 +7,11 @@ please report any [issues](https://github.com/zx80/flask-tester/issues).
 
 ## TODO
 
-Add support for dataclass/pydantic parameters auto-serialization.
+Check whether data and json should be exclusive.
+
+## ? on ?
+
+Add support for transparent dataclass and pydantic parameters.
 
 ## 4.0 on 2024-05-20
 

pyproject.toml

@@ -33,7 +33,14 @@ package = "https://pypi.org/project/FlaskTester/"
 
 [project.optional-dependencies]
 # various dev tools
-dev = ["mypy", "pyright", "ruff", "coverage", "pymarkdownlnt!=0.9.5", "build", "twine", "wheel", "types-flask", "types-requests", "FlaskSimpleAuth>=30.0", "passlib"]
+dev = [
+  # static checks…
+  "mypy", "pyright", "ruff", "coverage", "pymarkdownlnt!=0.9.5",
+  # packaging
+  "build", "twine", "wheel",
+  # tests
+  "types-flask", "types-requests", "FlaskSimpleAuth>=30.0", "passlib", "pydantic"
+]
 # documentation generation
 doc = ["sphinx", "sphinx_rtd_theme", "sphinx-autoapi", "sphinx-lint", "myst_parser"]
 

tests/app.py

@@ -2,6 +2,7 @@
 
 import FlaskSimpleAuth as fsa
 import secret
+import model
 
 # create application with token, param and basic authentication
 app = fsa.Flask("app", FSA_MODE="dev", FSA_AUTH=["token", "param", "basic"])
@@ -38,3 +39,37 @@ def get_admin(user: fsa.CurrentUser):
 @app.get("/hello", authorize="OPEN")
 def get_hello(lang: fsa.Cookie = "en"):
     return {"lang": lang, "hello": HELLO.get(lang, "Hi")}, 200
+
+# json, pydantic and dataclasses
+# FIXME could we drop fsa.jsonify?
+@app.get("/t0", authorize="OPEN")
+def get_t0(t: fsa.JsonData):
+    return fsa.jsonify(t)
+
+@app.post("/t0", authorize="OPEN")
+def post_t0(t: fsa.JsonData):
+    return fsa.jsonify(t)
+
+@app.get("/t1", authorize="OPEN")
+def get_t1(t: model.Thing1):
+    return fsa.jsonify(t)
+
+@app.post("/t1", authorize="OPEN")
+def post_t1(t: model.Thing1):
+    return fsa.jsonify(t)
+
+@app.get("/t2", authorize="OPEN")
+def get_t2(t: model.Thing2):
+    return fsa.jsonify(t)
+
+@app.post("/t2", authorize="OPEN")
+def post_t2(t: model.Thing2):
+    return fsa.jsonify(t)
+
+@app.get("/t3", authorize="OPEN")
+def get_t3(t: model.Thing3):
+    return fsa.jsonify(t)
+
+@app.post("/t3", authorize="OPEN")
+def post_t3(t: model.Thing3):
+    return fsa.jsonify(t)

tests/model.py

@@ -0,0 +1,19 @@
+import pydantic
+import dataclasses
+
+class Thing1(pydantic.BaseModel):
+    tid: int
+    name: str
+    owner: str
+
+@pydantic.dataclasses.dataclass
+class Thing2:
+    tid: int
+    name: str
+    owner: str
+
+@dataclasses.dataclass
+class Thing3:
+    tid: int
+    name: str
+    owner: str

tests/test_app.py

@@ -8,6 +8,7 @@
 import threading
 import io
 import logging
+import model
 
 logging.basicConfig(level=logging.INFO)
 # logging.basicConfig(level=logging.DEBUG)
@@ -338,3 +339,35 @@ def test_client_fixture():
     # reset env
     if app:
         os.environ["FLASK_TESTER_APP"] = app
+
+def test_classes(api):
+
+    def thing_eq(ta, tb):
+        tb = model.Thing1(**tb) if isinstance(tb, dict) else tb
+        return ta.tid == tb.tid and ta.name == tb.name and ta.owner == tb.owner
+
+    # Things
+    t0 = {"tid": 0, "name": "zero", "owner": "Rosalyn"}
+    t1 = model.Thing1(tid=1, name="one", owner="Susie")
+    t2 = model.Thing2(tid=2, name="two", owner="Calvin")
+    t3 = model.Thing3(tid=3, name="three", owner="Hobbes")
+
+    n = 0
+    # check all combinations
+    for path in ["/t0", "/t1", "/t2", "/t3"]:
+        for param in [t0, t1, t2, t3]:
+            for tclass in [model.Thing1, model.Thing2, model.Thing3]:
+                for method in ["GET", "POST"]:
+                    for mode in ["data", "json"]:
+                        n +=1
+                        parameter = {mode: {"t": param}}
+                        res = api.request(method, path, 200, **parameter)
+                        assert res.is_json
+                        json = res.json
+                        assert isinstance(json, dict)
+                        assert thing_eq(tclass(**json), param)
+    assert n == 192
+
+    # null translation
+    assert api.get("/t0", 200, json={"t": None}).json is None
+    assert api.get("/t0", 200, data={"t": None}).json is None