FlaskTester 3.6__tar.gz → 4.1__tar.gz

{FlaskTester-3.6 → flasktester-4.1}/FlaskTester.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FlaskTester
-Version: 3.6
+Version: 4.1
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
 License: CC0
@@ -34,6 +34,7 @@ Requires-Dist: types-flask; extra == "dev"
 Requires-Dist: types-requests; extra == "dev"
 Requires-Dist: FlaskSimpleAuth>=30.0; extra == "dev"
 Requires-Dist: passlib; extra == "dev"
+Requires-Dist: pydantic; extra == "dev"
 Provides-Extra: doc
 Requires-Dist: sphinx; extra == "doc"
 Requires-Dist: sphinx_rtd_theme; extra == "doc"
@@ -49,7 +50,7 @@ either with internal Flask tests (aka `test_client`) or external tests (with
 authentication and per-user cookies.
 
 Only one set of tests is needed, switching from internal to external is
-achieved through environment variables.
+achieved by setting an environment variable.
 
 ![Status](https://github.com/zx80/flask-tester/actions/workflows/package.yml/badge.svg?branch=main&style=flat)
 ![Tests](https://img.shields.io/badge/tests-14%20✓-success)
@@ -123,7 +124,7 @@ The above test runs with [`tests/app.py`](tests/app.py)
 [Flask](https://flask.palletsprojects.com/)
 REST application back-end with password and token authentication based on
 [FlaskSimpleAuth](https://pypi.org/project/FlaskSimpleAuth/).
-The code uses _25_ lines of Python for implementing
+The code uses _23_ lines of Python for implementing
 password (basic and parameters) and token authentications,
 admin group authorization, and routes for
 token generation (2), identity tests (2) and an incredible open cookie-based

{FlaskTester-3.6 → flasktester-4.1}/FlaskTester.egg-info/requires.txt

@@ -15,6 +15,7 @@ types-flask
 types-requests
 FlaskSimpleAuth>=30.0
 passlib
+pydantic
 
 [doc]
 sphinx

{FlaskTester-3.6 → flasktester-4.1}/FlaskTester.py

@@ -9,7 +9,9 @@ import re
 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")
 
@@ -29,12 +31,15 @@ class _AssertError(FlaskTesterError):
     pass
 
 
-def _raiseError(msg: str):
-    """Undocumented switch for FlaskTester own tests."""
+def _pytestFail(msg: str):
+    """Undocumented switch for FlaskTester own tests.
+
+    A pytest test cannot check an expected pytest failure without failing.
+    """
     log.error(msg)
     if "FLASK_TESTER_TESTING" in os.environ:
         raise _AssertError(msg)
-    else:  # pragma: no cover  # cannot cover an expected pytest failure!
+    else:  # pragma: no cover
         pytest.fail(msg)
 
 
@@ -54,24 +59,24 @@ class Authenticator:
 
     Constructor parameters:
 
-    - ``allow``: list of allowed schemes.
-      default is ``["bearer", "basic", "param", "none"]``.
-    - ``user``: parameter for user on ``param`` password authentication,
-      default is ``USER``.
-    - ``pwd``: parameter for password on ``param`` password authentication,
-      default is ``PASS``.
-    - ``login``: parameter for user on ``fake`` authentication,
-      default is ``LOGIN``.
-    - ``bearer``: name of bearer scheme for token,
-      default is ``Bearer``.
-    - ``header``: name of header for token,
-      default is ``Auth``.
-    - ``cookie``: name of cookie for token,
-      default is ``auth``.
-    - ``tparam``: name of parameter for token,
-      default is ``AUTH``.
-    - ``ptype``: default parameter type, either ``data`` or ``json``,
-      default is ``data``.
+    :param allow: List of allowed schemes.
+        defaults to ``["bearer", "basic", "param", "none"]``.
+    :param user: Parameter for user on ``param`` password authentication,
+        defaults to ``"USER"``.
+    :param pwd: Parameter for password on ``param`` password authentication,
+        defaults to ``"PASS"``.
+    :param login: Parameter for user on ``fake`` authentication,
+        defaults to ``"LOGIN"``.
+    :param bearer: Name of bearer scheme for token,
+        defaults to ``"Bearer"``.
+    :param header: Name of header for token,
+        defaults to ``"Auth"``.
+    :param cookie: Name of cookie for token,
+        defaults to ``"auth"``.
+    :param tparam: Name of parameter for token,
+        defaults to ``"AUTH"``.
+    :param ptype: Default parameter type, either *data* or *json*,
+        defaults to ``"data"``.
 
     Note: default values are consistent with `FlaskSimpleAuth <https://pypi.org/project/FlaskSimpleAuth/>`_.
     """
@@ -182,12 +187,12 @@ class Authenticator:
     def setAuth(self, login: str|None, kwargs: dict[str, Any], cookies: dict[str, str], auth: str|None = None):
         """Set request authentication.
 
-        - ``login``: login target, None means no authentication.
-        - ``kwargs``: request parameters.
-        - ``cookies``: request cookies.
-        - ``auth``: authentication method, default is None.
+        :param login: Login target, *None* means no authentication.
+        :param kwargs: Request parameters to modify.
+        :param cookies: Request cookies to modify.
+        :param auth: Authentication method, default is *None*.
 
-        The default behavior is to try allowed schemes: tokens first,
+        The default behavior is to try allowed schemes: token first,
         then password, then fake.
         """
 
@@ -251,9 +256,9 @@ class Authenticator:
 class RequestFlaskResponse:
     """Wrapper to return a Flask-looking response from a request response.
 
-    This only work for simple responses.
+    This only works for simple responses.
 
-    Available attributes:
+    Available public attributes:
 
     - ``status_code``: integer status code.
     - ``data``: body as bytes.
@@ -265,7 +270,7 @@ class RequestFlaskResponse:
 
     Constructor parameter:
 
-    - ``response``: from request.
+    :param response: Response from request.
     """
 
     def __init__(self, response):
@@ -289,8 +294,8 @@ class Client:
 
     Constructor parameters:
 
-    - ``auth``: authenticator.
-    - ``default_login``: if ``login`` is not set.
+    :param auth: Authenticator.
+    :param default_login: When ``login`` is not set.
     """
 
     def __init__(self, auth: Authenticator, default_login: str|None = None):
@@ -320,16 +325,16 @@ class Client:
 
         Mandatory parameters:
 
-        - ``method``: HTTP method ("GET", "POST", "PATCH", "DELETE"…).
-        - ``path``: local path under the base URL.
+        :param method: HTTP method ("GET", "POST", "PATCH", "DELETE"…).
+        :param path: Local path under the base URL.
 
         Optional parameters:
 
-        - ``status``: expected HTTP status, *None* to skip status check.
-        - ``content``: regular expression for response body, *None* to skip content check.
-        - ``login``: authenticated user, use **explicit** *None* to skip.
-        - ``auth``: authentication scheme to use instead of default behavior.
-        - ``**kwargs``: more request parameters (headers, data, json…).
+        :param status: Expected HTTP status, *None* to skip status check.
+        :param content: Regular expression for response body, *None* to skip content check.
+        :param login: Authenticated user, use **explicit** *None* to skip default.
+        :param auth: Authentication scheme to use instead of default behavior.
+        :param **kwargs: More request parameters (headers, data, json…).
         """
 
         if "login" in kwargs:
@@ -343,54 +348,89 @@ class Client:
             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
-                _raiseError(f"bad {status} result: {res.status_code} {res.text[:512]}...")
+                # 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):
-                _raiseError(f"cannot find {content} in {res.text[:512]}...")
+                # FIXME what if the useful part is at the end?
+                _pytestFail(f"cannot find {content} in {res.text[:512]}...")
 
         return res
 
     def get(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
-        """HTTP GET request, see ``request`` parameters."""
+        """HTTP GET request, see `Client.request`."""
         return self.request("GET", path, status=status, content=content, **kwargs)
 
     def post(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
-        """HTTP POST request, see ``request`` parameters."""
+        """HTTP POST request, see `Client.request`."""
         return self.request("POST", path, status=status, content=content, **kwargs)
 
     def put(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
-        """HTTP PUT request, see ``request`` parameters."""
+        """HTTP PUT request, see `Client.request`."""
         return self.request("PUT", path, status=status, content=content, **kwargs)
 
     def patch(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
-        """HTTP PATCH request, see ``request`` parameters."""
+        """HTTP PATCH request, see `Client.request`."""
         return self.request("PATCH", path, status=status, content=content, **kwargs)
 
     def delete(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
-        """HTTP DELETE request, see ``request`` parameters."""
+        """HTTP DELETE request, see `Client.request`."""
         return self.request("DELETE", path, status=status, content=content, **kwargs)
 
-    def check(self, method: str, path: str, status: int, content: str|None = None, **kwargs):
-        """Deprecated, use ``request`` or HTTP-method-specific methods."""
-        return self.request(method, path, status=status, content=content, **kwargs)
-
 
 class RequestClient(Client):
     """Request-based test provider.
 
     Constructor parameters:
 
-    - ``auth``: authenticator.
-    - ``base_url``: target server.
-    - ``default_login``: if ``login`` is not set.
+    :param auth: Authenticator.
+    :param base_url: Target server.
+    :param default_login: When ``login`` is not set.
     """
 
     def __init__(self, auth: Authenticator, base_url: str, default_login=None):
@@ -434,9 +474,9 @@ class FlaskClient(Client):
 
     Constructor parameters:
 
-    - ``auth``: authenticator.
-    - ``client``: Flask actual ``test_client``.
-    - ``default_login``: if ``login`` is not set.
+    :param auth: Authenticator.
+    :param client: Flask actual ``test_client``.
+    :param default_login: When ``login`` is not set.
 
     Note: this client handles `cookies`.
     """
@@ -499,29 +539,29 @@ def ft_authenticator():
     Environment variables:
 
     - ``FLASK_TESTER_LOG_LEVEL``: package log level in
-      ``DEBUG INFO WARNING ERROR CRITICAL NOSET``.
-      Default is ``NOTSET``.
+      ``DEBUG INFO WARNING ERROR CRITICAL NOSET``,
+      defaults to ``NOTSET``.
     - ``FLASK_TESTER_ALLOW``: allowed space-separated authentication schemes, in
-      ``basic param bearer header cookie tparam fake none``.
-      Default is ``bearer basic param none``.
-    - ``FLASK_TESTER_USER``: user login parameter for ``param`` authentication.
-      Default is ``USER``.
-    - ``FLASK_TESTER_PASS``: user password parameter for ``param`` authentication.
-      Default is ``PASS``.
-    - ``FLASK_TESTER_LOGIN``: user login parameter for ``fake`` authentication.
-      Default is ``LOGIN``.
-    - ``FLASK_TESTER_BEARER``: bearer name for *token* authentication.
-      Default is ``Bearer``.
-    - ``FLASK_TESTER_HEADER``: header name for *token* authentication.
-      Default is ``Auth``.
-    - ``FLASK_TESTER_COOKIE``: cookie name for *token* authentication.
-      Default is ``auth``.
-    - ``FLASK_TESTER_TPARAM``: parameter for *token* authentication.
-      Default is ``AUTH``.
-    - ``FLASK_TESTER_PTYPE``: default parameter type, ``data`` or ``json``.
-      Default is ``data``.
-    - ``FLASK_TESTER_AUTH``: initial comma-separated list of *login:password*.
-      Default is not set.
+      ``basic param bearer header cookie tparam fake none``,
+      defaults to ``bearer basic param none``.
+    - ``FLASK_TESTER_USER``: user login parameter for ``param`` authentication,
+      defaults to ``USER``.
+    - ``FLASK_TESTER_PASS``: user password parameter for ``param`` authentication,
+      defaults to ``PASS``.
+    - ``FLASK_TESTER_LOGIN``: user login parameter for ``fake`` authentication,
+      defaults to ``LOGIN``.
+    - ``FLASK_TESTER_BEARER``: bearer name for *token* authentication,
+      defaults to ``Bearer``.
+    - ``FLASK_TESTER_HEADER``: header name for *token* authentication,
+      defaults to ``Auth``.
+    - ``FLASK_TESTER_COOKIE``: cookie name for *token* authentication,
+      defaults to ``auth``.
+    - ``FLASK_TESTER_TPARAM``: parameter for *token* authentication,
+      defaults to ``AUTH``.
+    - ``FLASK_TESTER_PTYPE``: default parameter type, ``data`` or ``json``,
+      defaults to ``data``.
+    - ``FLASK_TESTER_AUTH``: initial comma-separated list of *login:password*,
+      defaults to not set.
     """
 
     yield _ft_authenticator()
@@ -532,28 +572,30 @@ def _ft_client(authenticator):
     default_login = os.environ.get("FLASK_TESTER_DEFAULT", None)
     client: Client
 
-    app_def = os.environ.get("FLASK_TESTER_URL", "app")
-    app_def = os.environ.get("FLASK_TESTER_APP", app_def)
+    test_app = os.environ.get("FLASK_TESTER_APP", "app")
 
-    if app_def.startswith("http://") or app_def.startswith("https://"):
-        client = RequestClient(authenticator, app_def, default_login)
+    if test_app.startswith("http://") or test_app.startswith("https://"):
+        client = RequestClient(authenticator, test_app, default_login)
     else:
         # load app package
-        pkg_name, app = app_def, None
-        app_names = ["app", "application", "create_app", "make_app"]
-        if ":" in pkg_name:  # override defaults
-            pkg_name, app_name = pkg_name.split(":", 1)
+        if ":" in test_app:  # override defaults
+            pkg_name, app_name = test_app.split(":", 1)
             app_names = [app_name]
+        else:
+            pkg_name = test_app
+            app_names = ["app", "application", "create_app", "make_app"]
         pkg = importlib.import_module(pkg_name)
         # find app in package
+        app = None
         for name in app_names:
             if hasattr(pkg, name):
                 app = getattr(pkg, name)
                 if callable(app) and not hasattr(app, "test_client"):
                     app = app()
                 break
+        # none found
         if not app:
-            raise FlaskTesterError(f"cannot find Flask app in {pkg_name}")
+            raise FlaskTesterError(f"cannot find Flask app in {pkg_name} ({test_app})")
         client = FlaskClient(authenticator, app.test_client(), default_login)
 
     return client
@@ -562,7 +604,7 @@ def _ft_client(authenticator):
 def ft_client(ft_authenticator):
     """Pytest Fixture: ft_client.
 
-    Target environment variable:
+    Mandatory target environment variable:
 
     - ``FLASK_TESTER_APP``: find the Flask application, eg
       ``app:create_app`` for an internal test, or

{FlaskTester-3.6 → flasktester-4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FlaskTester
-Version: 3.6
+Version: 4.1
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
 License: CC0
@@ -34,6 +34,7 @@ Requires-Dist: types-flask; extra == "dev"
 Requires-Dist: types-requests; extra == "dev"
 Requires-Dist: FlaskSimpleAuth>=30.0; extra == "dev"
 Requires-Dist: passlib; extra == "dev"
+Requires-Dist: pydantic; extra == "dev"
 Provides-Extra: doc
 Requires-Dist: sphinx; extra == "doc"
 Requires-Dist: sphinx_rtd_theme; extra == "doc"
@@ -49,7 +50,7 @@ either with internal Flask tests (aka `test_client`) or external tests (with
 authentication and per-user cookies.
 
 Only one set of tests is needed, switching from internal to external is
-achieved through environment variables.
+achieved by setting an environment variable.
 
 ![Status](https://github.com/zx80/flask-tester/actions/workflows/package.yml/badge.svg?branch=main&style=flat)
 ![Tests](https://img.shields.io/badge/tests-14%20✓-success)
@@ -123,7 +124,7 @@ The above test runs with [`tests/app.py`](tests/app.py)
 [Flask](https://flask.palletsprojects.com/)
 REST application back-end with password and token authentication based on
 [FlaskSimpleAuth](https://pypi.org/project/FlaskSimpleAuth/).
-The code uses _25_ lines of Python for implementing
+The code uses _23_ lines of Python for implementing
 password (basic and parameters) and token authentications,
 admin group authorization, and routes for
 token generation (2), identity tests (2) and an incredible open cookie-based

{FlaskTester-3.6 → flasktester-4.1}/README.md

@@ -6,7 +6,7 @@ either with internal Flask tests (aka `test_client`) or external tests (with
 authentication and per-user cookies.
 
 Only one set of tests is needed, switching from internal to external is
-achieved through environment variables.
+achieved by setting an environment variable.
 
 ![Status](https://github.com/zx80/flask-tester/actions/workflows/package.yml/badge.svg?branch=main&style=flat)
 ![Tests](https://img.shields.io/badge/tests-14%20✓-success)
@@ -80,7 +80,7 @@ The above test runs with [`tests/app.py`](tests/app.py)
 [Flask](https://flask.palletsprojects.com/)
 REST application back-end with password and token authentication based on
 [FlaskSimpleAuth](https://pypi.org/project/FlaskSimpleAuth/).
-The code uses _25_ lines of Python for implementing
+The code uses _23_ lines of Python for implementing
 password (basic and parameters) and token authentications,
 admin group authorization, and routes for
 token generation (2), identity tests (2) and an incredible open cookie-based

{FlaskTester-3.6 → flasktester-4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "FlaskTester"
-version = "3.6"
+version = "4.1"
 authors = [ { name = "Fabien Coelho", email = "flask.tester@coelho.net" } ]
 description = "Pytest fixtures for Flask internal and external authenticated tests"
 readme = "README.md"
@@ -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"]
 

{FlaskTester-3.6 → flasktester-4.1}/tests/test_app.py

@@ -8,6 +8,7 @@ import http.server as htsv
 import threading
 import io
 import logging
+import model
 
 logging.basicConfig(level=logging.INFO)
 # logging.basicConfig(level=logging.DEBUG)
@@ -22,7 +23,7 @@ os.environ.update(
 
 def test_sanity():
     # must provide url or package of Flask application to test
-    assert "FLASK_TESTER_URL" in os.environ or "FLASK_TESTER_APP" in os.environ
+    assert "FLASK_TESTER_APP" in os.environ
     # log.debug(f"TEST_SEED={os.environ.get('TEST_SEED')}")
 
 # example from README.md
@@ -296,7 +297,7 @@ def test_request_client():
     try:
         client = ft.RequestClient(ft.Authenticator(), "http://localhost:8888")
         client.get("/", 200)
-        client.check("GET", "/", 200)
+        client.request("GET", "/", 200)
         hello = io.BytesIO(b"hello world")
         client.post("/", 501, data={"hello": hello})
         hello = io.BytesIO(b"hello world")
@@ -309,10 +310,6 @@ def test_client_fixture():
     # ft_client coverage
     auth = ft._ft_authenticator()
     # check and save env
-    url = None
-    if "FLASK_TESTER_URL" in os.environ:  # pragma: no cover
-        url = os.environ["FLASK_TESTER_URL"]
-        del os.environ["FLASK_TESTER_URL"]
     app = None
     if "FLASK_TESTER_APP" in os.environ:
         app = os.environ["FLASK_TESTER_APP"]
@@ -320,10 +317,10 @@ def test_client_fixture():
     # no url nor app, defaults to "app"
     init = ft._ft_client(auth)
     # url
-    os.environ["FLASK_TESTER_URL"] = "http://localhost:5000"
+    os.environ["FLASK_TESTER_APP"] = "http://localhost:5000"
     init = ft._ft_client(auth)
     assert isinstance(init, ft.RequestClient)
-    del os.environ["FLASK_TESTER_URL"]
+    del os.environ["FLASK_TESTER_APP"]
     # bad package
     os.environ["FLASK_TESTER_APP"] = "no_such_package"
     try:
@@ -340,7 +337,37 @@ def test_client_fixture():
         assert True, "expected error raised"
     del os.environ["FLASK_TESTER_APP"]
     # reset env
-    if url:  # pragma: no cover
-        os.environ["FLASK_TESTER_URL"] = url
     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

flasktester-4.1/tests/test_app2.py

@@ -0,0 +1,28 @@
+import os
+import pytest
+from FlaskTester import ft_client, ft_authenticator
+import secret
+
+os.environ.update(FLASK_TESTER_ALLOW="basic param none")
+
+@pytest.fixture
+def app(ft_client):
+    ft_client.setPass("calvin", secret.PASSES["calvin"])
+    ft_client.setCookie("calvin", "lang", "en")
+    ft_client.setPass("hobbes", secret.PASSES["hobbes"])
+    ft_client.setCookie("hobbes", "lang", "fr")
+    yield ft_client
+
+def test_something(app):
+    # requires an authentication
+    app.get("/authenticated", 401, login=None)
+    app.get("/authenticated", 200, "Hello", login="calvin")
+    app.get("/authenticated", 200, "Bonjour", login="hobbes")
+    # only allowed to calvin
+    app.get("/only-admin", 401, login=None)
+    app.get("/only-admin", 200, "administrateur", login="calvin")
+    app.get("/only-admin", 403, "not in group", login="hobbes")
+    # no authentication required, but depends on lang
+    app.get("/open", 200, "Hello", login="calvin", auth="none")
+    app.get("/open", 200, "Bonjour", login="hobbes", auth="none")
+    app.get("/open", 200, "Guten Tag", login=None)

FlaskTester-3.6/tests/test_app2.py

@@ -1,28 +0,0 @@
-import os
-import pytest
-from FlaskTester import ft_client, ft_authenticator
-
-os.environ.update(FLASK_TESTER_ALLOW="basic param none")
-
-@pytest.fixture
-def app(ft_client):
-    ft_client.setPass("calvin", "clv-pw")
-    ft_client.setCookie("calvin", "lang", "en")
-    ft_client.setPass("hobbes", "hbs-pw")
-    ft_client.setCookie("hobbes", "lang", "fr")
-    yield ft_client
-
-def test_something(app):
-    # requires an authentication
-    app.get("/authenticated", 401, login=None)
-    res = app.get("/authenticated", 200, login="calvin")
-    assert "Hello" in res.text
-    app.get("/authenticated", 200, "Bonjour", login="hobbes")
-    # only allowed to calvin
-    app.get("/only-calvin", 401, login=None)
-    app.get("/only-calvin", 200, login="calvin")
-    app.get("/only-calvin", 403, login="hobbes")
-    # no authentication required, but depends on lang
-    res = app.get("/no-auth", 200, login="calvin", auth="none")
-    assert "Hello" in res.text
-    app.get("/no-auth", 200, "Bonjour", login="hobbes", auth="none")