FlaskTester 1.2__tar.gz → 1.4__tar.gz

{FlaskTester-1.2 → FlaskTester-1.4}/FlaskTester.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FlaskTester
-Version: 1.2
+Version: 1.4
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
 License: CC0
@@ -39,6 +39,7 @@ Requires-Dist: sphinx; extra == "doc"
 Requires-Dist: sphinx_rtd_theme; extra == "doc"
 Requires-Dist: sphinx-autoapi; extra == "doc"
 Requires-Dist: sphinx-lint; extra == "doc"
+Requires-Dist: myst_parser; extra == "doc"
 
 # FlaskTester - Pytest fixtures for Flask internal and external authenticated tests
 
@@ -64,37 +65,48 @@ achieved through environment variables.
 Install package with `pip install FlaskTester` or equivalent.
 
 The following test creates a local fixture with 2 users identified by a
-password, and retrieves a token for the first user using a `/token` route
+password, and retrieves tokens for both users using a `/login` route
 provided by the application.
-It then proceeds to run some requests against the `/admin` route.
+It then proceeds to run authenticated requests against the `/admin` route.
 
 ```python
-import secret
 import pytest
 from FlaskTester import ft_authenticator, ft_client
+import secret
 
 @pytest.fixture
 def app(ft_client):
     # add test passwords for Calvin and Hobbes (must be consistent with app!)
     ft_client.setPass("calvin", secret.PASSES["calvin"])
     ft_client.setPass("hobbes", secret.PASSES["hobbes"])
-    # get Calvin's token, assume json result {"token": "<token-value>"}
-    res = ft_client.get("/token", login="calvin", auth="basic", status=200)
+    # get user tokens, assume json result {"token": "<token-value>"}
+    res = ft_client.get("/login", login="calvin", auth="basic", status=200)
     assert res.is_json
     ft_client.setToken("calvin", res.json["token"])
+    res = ft_client.post("/login", login="hobbes", auth="param", status=201)
+    assert res.is_json
+    ft_client.setToken("hobbes", res.json["token"])
     # return working client
     yield ft_client
 
-def test_app(app):
+def test_app_admin(app):
+    # try all authentication schemes for calvin
     app.get("/admin", login="calvin", auth="bearer", status=200)
     app.get("/admin", login="calvin", auth="basic", status=200)
+    app.get("/admin", login="calvin", auth="param", status=200)
+    # try all authentication schemes for hobbes
+    res = app.get("/admin", login="hobbes", auth="bearer", status=403)
+    assert 'not in group "ADMIN"' in res.text
     res = app.get("/admin", login="hobbes", auth="basic", status=403)
     assert 'not in group "ADMIN"' in res.text
+    res = app.get("/admin", login="hobbes", auth="param", status=403)
+    assert 'not in group "ADMIN"' in res.text
 ```
 
 This can be run against a (local) server:
 
 ```shell
+export TEST_SEED="some-random-data"              # shared seed
 flask --app app:app run &                        # start flask app
 pid=$!                                           # keep pid
 export FLASK_TESTER_URL="http://localhost:5000"  # set app local url
@@ -213,23 +225,29 @@ The implementation of these fixtures is based on five classes plus exceptions:
 
 ## License
 
-This code is public domain.
+This code is [Public Domain](https://creativecommons.org/publicdomain/zero/1.0/).
+
+All software has bug, this is software, hence… Beware that you may lose your
+hairs or your friends because of it. If you like it, feel free to send a
+postcard to the author.
+
+## Versions
 
 Packages are distributed from [PyPI](https://pypi.org/project/FlaskTester/),
 [sources](https://github.com/zx80/flask-tester) are available on GitHub,
 see also the [documentation](https://zx80.github.io/flask-tester/),
 please report any [issues](https://github.com/zx80/flask-tester/issues).
 
-## See Also, or Not
-
-- [Flask Testing](https://github.com/jarus/flask-testing) an unmaintained
-  old-style unit test for Flask 1.x, without authentication help.
+### 1.4 on 2024-03-19
 
-## TODO
+Test expected assert failures.
+Improved API documentation.
+Keep first found app.
 
-- API documentation generation
+### 1.3 on 2024-03-16
 
-## Versions
+Generate API documentation.
+Cleaner code.
 
 ### 1.2 on 2024-03-15
 
@@ -255,3 +273,8 @@ Working coverage tests.
 ### 0.9 on 2024-03-11
 
 Initial revision extracted from a separate project.
+
+## See Also, or Not
+
+- [Flask Testing](https://github.com/jarus/flask-testing) an unmaintained
+  old-style unit test for Flask 1.x, without authentication help.

{FlaskTester-1.2 → FlaskTester-1.4}/FlaskTester.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 FlaskTester.py
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 FlaskTester.egg-info/PKG-INFO

{FlaskTester-1.2 → FlaskTester-1.4}/FlaskTester.egg-info/requires.txt

@@ -21,3 +21,4 @@ sphinx
 sphinx_rtd_theme
 sphinx-autoapi
 sphinx-lint
+myst_parser

{FlaskTester-1.2 → FlaskTester-1.4}/FlaskTester.py

@@ -1,3 +1,8 @@
+"""FlaskTester - Pytest fixtures for Flask authenticated internal and external tests.
+
+Pytest: PYTEST_DONT_REWRITE
+"""
+
 import os
 import io
 import re
@@ -10,10 +15,12 @@ log = logging.getLogger("flask_tester")
 
 
 class FlaskTesterError(BaseException):
+    """Base exception for FlaskTester package."""
     pass
 
 
 class AuthError(FlaskTesterError):
+    """Authenticator Exception."""
     pass
 
 
@@ -21,13 +28,33 @@ class Authenticator:
     """Manage authentication for test requests.
 
     Supported schemes:
+
     - ``basic``: HTTP Basic Authentication
     - ``param``: password with HTTP or JSON parameters
-    - ``bearer``: token in ``Authorization`` _bearer_ header
+    - ``bearer``: token in ``Authorization`` *bearer* header
     - ``header``: token in a header
     - ``cookie``: token in a cookie
     - ``tparam``: token in a parameter
     - ``fake``: fake scheme, login directly passed as a parameter
+
+    Constructor parameters:
+
+    - ``allow``: list of allowed schemes.
+      default is ``["bearer", "basic", "param"]``
+    - ``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``
     """
 
     _TOKEN_SCHEMES = {"bearer", "header", "cookie", "tparam"}
@@ -50,25 +77,6 @@ class Authenticator:
              cookie: str = "auth",
              tparam: str = "AUTH",
          ):
-        """Constructor parameters:
-
-        - ``allow``: list of allowed schemes.
-          default is ``["bearer", "basic", "param"]``
-        - ``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``
-        """
 
         self._has_pass, self._has_token = False, False
         for auth in allow:
@@ -199,20 +207,21 @@ class RequestFlaskResponse:
     This only work for simple responses.
 
     Available attributes:
-    - status_code: integer status code
-    - data: body as bytes
-    - text: body as a string
-    - headers: dict of headers and their values
-    - cookies: dict of cookies
-    - json: JSON-converted body, or None
-    - is_json: whether body was in JSON
+
+    - ``status_code``: integer status code
+    - ``data``: body as bytes
+    - ``text``: body as a string
+    - ``headers``: dict of headers and their values
+    - ``cookies``: dict of cookies
+    - ``json``: JSON-converted body, or None
+    - ``is_json``: whether body was in JSON
+
+    Constructor parameter:
+
+    - ``response``: from request.
     """
 
     def __init__(self, response):
-        """Constructor parameter
-
-        - ``response`` from request.
-        """
 
         self._response = response
         self.status_code = response.status_code
@@ -229,23 +238,24 @@ class RequestFlaskResponse:
 
 
 class Client:
-    """Common class for flask authenticated testing."""
+    """Common class for flask authenticated testing.
 
-    def __init__(self, auth: Authenticator, default_login: str|None = None):
-        """Constructor parameters.
+    Constructor parameters:
 
-        - ``auth`` authenticator
-        - ``default_login`` if not ``login`` is set.
-        """
+    - ``auth`` authenticator
+    - ``default_login`` if not ``login`` is set.
+    """
+
+    def __init__(self, auth: Authenticator, default_login: str|None = None):
         self._auth = auth
         self._default_login = default_login
 
     def setToken(self, login: str, token: str|None):
-        """Associate a token to a login, None to remove."""
+        """Associate a token to a login, *None* to remove."""
         self._auth.setToken(login, token)
 
     def setPass(self, login: str, password: str|None):
-        """Associate a password to a login, None to remove."""
+        """Associate a password to a login, *None* to remove."""
         self._auth.setPass(login, password)
 
     def _request(self, method: str, path: str, **kwargs):
@@ -256,14 +266,16 @@ class Client:
         """Run a possibly authenticated HTTP request.
 
         Mandatory parameters:
-        - method: HTTP method ("GET", "POST", "PATCH", "DELETE"…)
-        - path: local path under the base URL
+
+        - ``method``: HTTP method ("GET", "POST", "PATCH", "DELETE"…)
+        - ``path``: local path under the base URL
 
         Optional parameters:
-        - status: expected HTTP status, None to skip status check
-        - login: authenticated user, use **explicit** None to skip
-        - auth: authentication schme to use
-        - **kwargs: more request parameters (headers, data, json…)
+
+        - ``status``: expected HTTP status, *None* to skip status check
+        - ``login``: authenticated user, use **explicit** *None* to skip
+        - ``auth``: authentication scheme to use
+        - ``**kwargs``: more request parameters (headers, data, json…)
         """
 
         if "login" in kwargs:
@@ -276,9 +288,9 @@ class Client:
         res = self._request(method, path, **kwargs)  # type: ignore
 
         if status is not None:
-            if res.status_code != status:  # pragma: no cover  # show error before aborting
+            if res.status_code != status:  # show error before aborting
                 log.error(f"bad {status} result: {res.status_code} {res.text[:512]}")
-            assert res.status_code == status
+            assert res.status_code == status, f"unexpected status {res.status_code}, expecting {status}"
 
         return res
 
@@ -306,14 +318,16 @@ class Client:
         """Run a query and check the response.
 
         Mandatory parameters:
-        - method: HTTP method ("GET", "POST", "PATCH", "DELETE"…)
-        - path: local path under the base URL
-        - status: expected HTTP status
+
+        - ``method``: HTTP method ("GET", "POST", "PATCH", "DELETE"…)
+        - ``path``: local path under the base URL
+        - ``status``: expected HTTP status
 
         Optional parameters:
-        - content: regular expression in response body
-        - login: authenticated user, use explicit None to skip
-        - **kwargs: more request parameters (headers, data, json…)
+
+        - ``content``: regular expression in response body
+        - ``login``: authenticated user, use explicit *None* to skip
+        - ``**kwargs``: more request parameters (headers, data, json…)
         """
 
         # get HTTP response
@@ -321,23 +335,24 @@ class Client:
 
         # check contents
         if content is not None:
-            if not re.search(content, res.text, re.DOTALL):  # pragma: no cover
+            if not re.search(content, res.text, re.DOTALL):
                 log.error(f"cannot find {content} in {res.text}")
-                assert False, "content not found"
+                assert False, f"expected content {content} not found in {res.text}"
 
         return res
 
 
 class RequestClient(Client):
-    """Request-based test provider."""
+    """Request-based test provider.
 
-    def __init__(self, auth: Authenticator, base_url: str, default_login=None):
-        """Constructor parameters.
+    Constructor parameters:
 
-        - ``auth`` authenticator
-        - ``base_url`` target server
-        - ``default_login`` if not ``login`` is set.
-        """
+    - ``auth`` authenticator
+    - ``base_url`` target server
+    - ``default_login`` if not ``login`` is set.
+    """
+
+    def __init__(self, auth: Authenticator, base_url: str, default_login=None):
         super().__init__(auth, default_login)
         self._base_url = base_url
         # reuse connections, otherwise it is too slow…
@@ -374,15 +389,16 @@ class RequestClient(Client):
 
 
 class FlaskClient(Client):
-    """Flask-based test provider."""
+    """Flask-based test provider.
 
-    def __init__(self, auth: Authenticator, client, default_login=None):
-        """Constructor parameters.
+    Constructor parameters:
 
-        - ``auth`` authenticator
-        - ``client`` Flask ``test_client``
-        - ``default_login`` if not ``login`` is set.
-        """
+    - ``auth`` authenticator
+    - ``client`` Flask ``test_client``
+    - ``default_login`` if not ``login`` is set.
+    """
+
+    def __init__(self, auth: Authenticator, client, default_login=None):
         super().__init__(auth, default_login)
         self._client = client
 
@@ -393,7 +409,31 @@ class FlaskClient(Client):
 
 @pytest.fixture
 def ft_authenticator():
-    """Pytest Fixture: ft_authenticator."""
+    """Pytest Fixture: ft_authenticator.
+
+    Environment variables:
+
+    - ``FLASK_TESTER_LOG_LEVEL``: package log level in
+      ``DEBUG INFO WARNING ERROR CRITICAL NOSET``.
+    - ``FLASK_TESTER_ALLOW``: allowed space-separated authentication schemes, in
+      ``basic param bearer header cookie tparam fake``.
+      Default is ``bearer basic param``.
+    - ``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_AUTH``: initial comma-separated list of *login:password*.
+    """
 
     level = os.environ.get("FLASK_TESTER_LOG_LEVEL", "NOTSET")
     log.setLevel(logging.DEBUG if level == "DEBUG" else
@@ -425,7 +465,18 @@ def ft_authenticator():
 
 @pytest.fixture
 def ft_client(ft_authenticator):
-    """Pytest Fixture: ft_client."""
+    """Pytest Fixture: ft_client.
+
+    Target environment variable, one **must** be defined:
+
+    - ``FLASK_TESTER_URL``: application HTTP base URL.
+    - ``FLASK_TESTER_APP``: Flask application, eg ``app:create_app``.
+
+    Other environment variable:
+
+    - ``FLASK_TESTER_DEFAULT``: Default client login, default is *None* for no
+      default.
+    """
 
     default_login = os.environ.get("FLASK_TESTER_DEFAULT", None)
     client: Client
@@ -450,6 +501,7 @@ def ft_client(ft_authenticator):
                 app = getattr(pkg, name)
                 if callable(app) and not hasattr(app, "test_client"):
                     app = app()
+                break
         if not app:  # pragma: no cover
             raise FlaskTesterError(f"cannot find Flask app in {pkg_name}")
         client = FlaskClient(ft_authenticator, app.test_client(), default_login)

FlaskTester-1.4/MANIFEST.in

@@ -0,0 +1 @@
+exclude docs/* */Makefile

{FlaskTester-1.2 → FlaskTester-1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FlaskTester
-Version: 1.2
+Version: 1.4
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
 License: CC0
@@ -39,6 +39,7 @@ Requires-Dist: sphinx; extra == "doc"
 Requires-Dist: sphinx_rtd_theme; extra == "doc"
 Requires-Dist: sphinx-autoapi; extra == "doc"
 Requires-Dist: sphinx-lint; extra == "doc"
+Requires-Dist: myst_parser; extra == "doc"
 
 # FlaskTester - Pytest fixtures for Flask internal and external authenticated tests
 
@@ -64,37 +65,48 @@ achieved through environment variables.
 Install package with `pip install FlaskTester` or equivalent.
 
 The following test creates a local fixture with 2 users identified by a
-password, and retrieves a token for the first user using a `/token` route
+password, and retrieves tokens for both users using a `/login` route
 provided by the application.
-It then proceeds to run some requests against the `/admin` route.
+It then proceeds to run authenticated requests against the `/admin` route.
 
 ```python
-import secret
 import pytest
 from FlaskTester import ft_authenticator, ft_client
+import secret
 
 @pytest.fixture
 def app(ft_client):
     # add test passwords for Calvin and Hobbes (must be consistent with app!)
     ft_client.setPass("calvin", secret.PASSES["calvin"])
     ft_client.setPass("hobbes", secret.PASSES["hobbes"])
-    # get Calvin's token, assume json result {"token": "<token-value>"}
-    res = ft_client.get("/token", login="calvin", auth="basic", status=200)
+    # get user tokens, assume json result {"token": "<token-value>"}
+    res = ft_client.get("/login", login="calvin", auth="basic", status=200)
     assert res.is_json
     ft_client.setToken("calvin", res.json["token"])
+    res = ft_client.post("/login", login="hobbes", auth="param", status=201)
+    assert res.is_json
+    ft_client.setToken("hobbes", res.json["token"])
     # return working client
     yield ft_client
 
-def test_app(app):
+def test_app_admin(app):
+    # try all authentication schemes for calvin
     app.get("/admin", login="calvin", auth="bearer", status=200)
     app.get("/admin", login="calvin", auth="basic", status=200)
+    app.get("/admin", login="calvin", auth="param", status=200)
+    # try all authentication schemes for hobbes
+    res = app.get("/admin", login="hobbes", auth="bearer", status=403)
+    assert 'not in group "ADMIN"' in res.text
     res = app.get("/admin", login="hobbes", auth="basic", status=403)
     assert 'not in group "ADMIN"' in res.text
+    res = app.get("/admin", login="hobbes", auth="param", status=403)
+    assert 'not in group "ADMIN"' in res.text
 ```
 
 This can be run against a (local) server:
 
 ```shell
+export TEST_SEED="some-random-data"              # shared seed
 flask --app app:app run &                        # start flask app
 pid=$!                                           # keep pid
 export FLASK_TESTER_URL="http://localhost:5000"  # set app local url
@@ -213,23 +225,29 @@ The implementation of these fixtures is based on five classes plus exceptions:
 
 ## License
 
-This code is public domain.
+This code is [Public Domain](https://creativecommons.org/publicdomain/zero/1.0/).
+
+All software has bug, this is software, hence… Beware that you may lose your
+hairs or your friends because of it. If you like it, feel free to send a
+postcard to the author.
+
+## Versions
 
 Packages are distributed from [PyPI](https://pypi.org/project/FlaskTester/),
 [sources](https://github.com/zx80/flask-tester) are available on GitHub,
 see also the [documentation](https://zx80.github.io/flask-tester/),
 please report any [issues](https://github.com/zx80/flask-tester/issues).
 
-## See Also, or Not
-
-- [Flask Testing](https://github.com/jarus/flask-testing) an unmaintained
-  old-style unit test for Flask 1.x, without authentication help.
+### 1.4 on 2024-03-19
 
-## TODO
+Test expected assert failures.
+Improved API documentation.
+Keep first found app.
 
-- API documentation generation
+### 1.3 on 2024-03-16
 
-## Versions
+Generate API documentation.
+Cleaner code.
 
 ### 1.2 on 2024-03-15
 
@@ -255,3 +273,8 @@ Working coverage tests.
 ### 0.9 on 2024-03-11
 
 Initial revision extracted from a separate project.
+
+## See Also, or Not
+
+- [Flask Testing](https://github.com/jarus/flask-testing) an unmaintained
+  old-style unit test for Flask 1.x, without authentication help.

{FlaskTester-1.2 → FlaskTester-1.4}/README.md

@@ -22,37 +22,48 @@ achieved through environment variables.
 Install package with `pip install FlaskTester` or equivalent.
 
 The following test creates a local fixture with 2 users identified by a
-password, and retrieves a token for the first user using a `/token` route
+password, and retrieves tokens for both users using a `/login` route
 provided by the application.
-It then proceeds to run some requests against the `/admin` route.
+It then proceeds to run authenticated requests against the `/admin` route.
 
 ```python
-import secret
 import pytest
 from FlaskTester import ft_authenticator, ft_client
+import secret
 
 @pytest.fixture
 def app(ft_client):
     # add test passwords for Calvin and Hobbes (must be consistent with app!)
     ft_client.setPass("calvin", secret.PASSES["calvin"])
     ft_client.setPass("hobbes", secret.PASSES["hobbes"])
-    # get Calvin's token, assume json result {"token": "<token-value>"}
-    res = ft_client.get("/token", login="calvin", auth="basic", status=200)
+    # get user tokens, assume json result {"token": "<token-value>"}
+    res = ft_client.get("/login", login="calvin", auth="basic", status=200)
     assert res.is_json
     ft_client.setToken("calvin", res.json["token"])
+    res = ft_client.post("/login", login="hobbes", auth="param", status=201)
+    assert res.is_json
+    ft_client.setToken("hobbes", res.json["token"])
     # return working client
     yield ft_client
 
-def test_app(app):
+def test_app_admin(app):
+    # try all authentication schemes for calvin
     app.get("/admin", login="calvin", auth="bearer", status=200)
     app.get("/admin", login="calvin", auth="basic", status=200)
+    app.get("/admin", login="calvin", auth="param", status=200)
+    # try all authentication schemes for hobbes
+    res = app.get("/admin", login="hobbes", auth="bearer", status=403)
+    assert 'not in group "ADMIN"' in res.text
     res = app.get("/admin", login="hobbes", auth="basic", status=403)
     assert 'not in group "ADMIN"' in res.text
+    res = app.get("/admin", login="hobbes", auth="param", status=403)
+    assert 'not in group "ADMIN"' in res.text
 ```
 
 This can be run against a (local) server:
 
 ```shell
+export TEST_SEED="some-random-data"              # shared seed
 flask --app app:app run &                        # start flask app
 pid=$!                                           # keep pid
 export FLASK_TESTER_URL="http://localhost:5000"  # set app local url
@@ -171,23 +182,29 @@ The implementation of these fixtures is based on five classes plus exceptions:
 
 ## License
 
-This code is public domain.
+This code is [Public Domain](https://creativecommons.org/publicdomain/zero/1.0/).
+
+All software has bug, this is software, hence… Beware that you may lose your
+hairs or your friends because of it. If you like it, feel free to send a
+postcard to the author.
+
+## Versions
 
 Packages are distributed from [PyPI](https://pypi.org/project/FlaskTester/),
 [sources](https://github.com/zx80/flask-tester) are available on GitHub,
 see also the [documentation](https://zx80.github.io/flask-tester/),
 please report any [issues](https://github.com/zx80/flask-tester/issues).
 
-## See Also, or Not
-
-- [Flask Testing](https://github.com/jarus/flask-testing) an unmaintained
-  old-style unit test for Flask 1.x, without authentication help.
+### 1.4 on 2024-03-19
 
-## TODO
+Test expected assert failures.
+Improved API documentation.
+Keep first found app.
 
-- API documentation generation
+### 1.3 on 2024-03-16
 
-## Versions
+Generate API documentation.
+Cleaner code.
 
 ### 1.2 on 2024-03-15
 
@@ -213,3 +230,8 @@ Working coverage tests.
 ### 0.9 on 2024-03-11
 
 Initial revision extracted from a separate project.
+
+## See Also, or Not
+
+- [Flask Testing](https://github.com/jarus/flask-testing) an unmaintained
+  old-style unit test for Flask 1.x, without authentication help.

{FlaskTester-1.2 → FlaskTester-1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "FlaskTester"
-version = "1.2"
+version = "1.4"
 authors = [ { name = "Fabien Coelho", email = "flask.tester@coelho.net" } ]
 description = "Pytest fixtures for Flask internal and external authenticated tests"
 readme = "README.md"
@@ -35,7 +35,7 @@ package = "https://pypi.org/project/FlaskTester/"
 # various dev tools
 dev = ["mypy", "pyright", "ruff", "coverage", "pymarkdownlnt!=0.9.5", "build", "twine", "wheel", "types-flask", "types-requests", "FlaskSimpleAuth", "passlib"]
 # documentation generation
-doc = ["sphinx", "sphinx_rtd_theme", "sphinx-autoapi", "sphinx-lint"]
+doc = ["sphinx", "sphinx_rtd_theme", "sphinx-autoapi", "sphinx-lint", "myst_parser"]
 
 [tool.setuptools]
 py-modules = [ "FlaskTester" ]

{FlaskTester-1.2 → FlaskTester-1.4}/tests/test.py

@@ -27,18 +27,28 @@ def app(ft_client):
     # add test passwords for Calvin and Hobbes (must be consistent with app!)
     ft_client.setPass("calvin", secret.PASSES["calvin"])
     ft_client.setPass("hobbes", secret.PASSES["hobbes"])
-    # get Calvin's token, assume json result {"token": "<token-value>"}
-    res = ft_client.get("/token", login="calvin", auth="basic", status=200)
+    # get user tokens, assume json result {"token": "<token-value>"}
+    res = ft_client.get("/login", login="calvin", auth="basic", status=200)
     assert res.is_json
     ft_client.setToken("calvin", res.json["token"])
+    res = ft_client.post("/login", login="hobbes", auth="param", status=201)
+    assert res.is_json
+    ft_client.setToken("hobbes", res.json["token"])
     # return working client
     yield ft_client
 
-def test_app(app):
+def test_app_admin(app):
+    # try all authentication schemes for calvin
     app.get("/admin", login="calvin", auth="bearer", status=200)
     app.get("/admin", login="calvin", auth="basic", status=200)
+    app.get("/admin", login="calvin", auth="param", status=200)
+    # try all authentication schemes for hobbes
+    res = app.get("/admin", login="hobbes", auth="bearer", status=403)
+    assert 'not in group "ADMIN"' in res.text
     res = app.get("/admin", login="hobbes", auth="basic", status=403)
     assert 'not in group "ADMIN"' in res.text
+    res = app.get("/admin", login="hobbes", auth="param", status=403)
+    assert 'not in group "ADMIN"' in res.text
 
 @pytest.fixture
 def api(ft_client):
@@ -50,13 +60,13 @@ def api(ft_client):
     ft_client.setPass("moe", "bad password")
     ft_client.setToken("moe", "bad token")
     # get valid tokens using password authn
-    res = ft_client.get("/token", login="calvin", auth="basic", status=200)
+    res = ft_client.get("/login", login="calvin", auth="basic", status=200)
     assert res.json["user"] == "calvin"
     ft_client._auth.setToken("calvin", res.json["token"])
-    res = ft_client.post("/token", login="hobbes", auth="param", status=201, data={})
+    res = ft_client.post("/login", login="hobbes", auth="param", status=201, data={})
     assert res.json["user"] == "hobbes"
     ft_client._auth.setToken("hobbes", res.json["token"])
-    res = ft_client.post("/token", login="susie", auth="param", status=201, json={})
+    res = ft_client.post("/login", login="susie", auth="param", status=201, json={})
     assert res.json["user"] == "susie"
     ft_client._auth.setToken("susie", res.json["token"])
     # check that token auth is ok
@@ -86,12 +96,22 @@ def test_admin(api):
         api.check("GET", "/admin", 403, login="hobbes", auth=auth)
         api.check("GET", "/admin", 401, login="moe", auth=auth)
         api.check("GET", "/admin", 401, login=None, auth=auth)
+        try:
+            api.check("GET", "/admin", status=599, login="calvin", auth=auth)
+            pytest.fail("assert on status must fail")  # pragma: no cover
+        except AssertionError as e:
+            assert "200" in str(e)
+        try:
+            api.check("GET", "/admin", status=200, login="calvin", auth=auth, content="NOT THERE")
+            pytest.fail("assert on content must fail")  # pragma: no cover
+        except AssertionError as e:
+            assert "NOT THERE" in str(e)
 
 def test_errors(api):
     for scheme in ("header", "cookie", "fake", "tparam", "unexpected"):
         try:
-            api.get("/token", login="calvin", auth=scheme)
-            assert False, "must raise an exception"  # pragma: no cover
+            api.get("/login", login="calvin", auth=scheme)
+            pytest.fail("must raise an exception")  # pragma: no cover
         except ft.AuthError as e:
             assert True, "expected error"
 
@@ -128,13 +148,13 @@ def test_authenticator_token():
     try:
         kwargs = {}
         auth.setAuth("dad", kwargs)
-        assert False, "must raise an error"  # pragma: no cover
+        pytest.fail("must raise an error")  # pragma: no cover
     except ft.FlaskTesterError:
         assert True, "error raised"
     # rosalyn as a password, but no password carrier is allowed
     try:
         auth.setPass("rosalyn", "rsln-pass")
-        assert False, "must raise an error"  # pragma: no cover
+        pytest.fail("must raise an error")  # pragma: no cover
     except ft.AuthError:
         assert True, "error raised"
     # force to trigger later errors
@@ -143,7 +163,7 @@ def test_authenticator_token():
     try:
         kwargs={}
         auth.setAuth("rosalyn", kwargs)
-        assert False, "must raise an error"  # pragma: no cover
+        pytest.fail("must raise an error")  # pragma: no cover
     except ft.FlaskTesterError:
         assert True, "error raised"
 
@@ -172,7 +192,7 @@ def test_authenticator_password():
     # susie as a token, but no token carrier is allowed
     try:
         auth.setToken("susie", "ss-token")
-        assert False, "must raise an error"  # pragma: no cover
+        pytest.fail("must raise an error")  # pragma: no cover
     except ft.FlaskTesterError:
         assert True, "error raised"
     # force to trigger later error
@@ -181,7 +201,7 @@ def test_authenticator_password():
     try:
         kwargs={}
         auth.setAuth("susie", kwargs)
-        assert False, "must raise an error"  # pragma: no cover
+        pytest.fail("must raise an error")  # pragma: no cover
     except ft.FlaskTesterError:
         assert True, "error raised"
 
@@ -214,9 +234,9 @@ def test_client():
     client = ft.Client(ft.Authenticator())
     try:
         client._request("GET", "/")
-        assert False, "must raise an error"  # pragma: no cover
+        pytest.fail("must raise an error")  # pragma: no cover
     except NotImplementedError:
-        assert True, "error raised"
+        assert True, "expected error raised"
 
 def test_request_client():
     httpd = htsv.HTTPServer(("", 8888), htsv.SimpleHTTPRequestHandler)