FlaskTester 3.3__tar.gz → 3.5__tar.gz

FlaskTester-3.5/FlaskTester.egg-info/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.1
+Name: FlaskTester
+Version: 3.5
+Summary: Pytest fixtures for Flask internal and external authenticated tests
+Author-email: Fabien Coelho <flask.tester@coelho.net>
+License: CC0
+Project-URL: repository, https://github.com/zx80/flask-tester
+Project-URL: documentation, https://zx80.github.io/flask-tester/
+Project-URL: issues, https://github.com/zx80/flask-tester/issues
+Project-URL: package, https://pypi.org/project/FlaskTester/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+Classifier: Programming Language :: Python
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Flask
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: flask
+Requires-Dist: pytest
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: pymarkdownlnt!=0.9.5; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: types-flask; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: FlaskSimpleAuth>=30.0; extra == "dev"
+Requires-Dist: passlib; extra == "dev"
+Provides-Extra: doc
+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
+
+This package allows to run authenticated tests against a Flask application,
+either with internal Flask tests (aka `test_client`) or external tests (with
+`requests` which performs actual HTTP requests), including password and token
+authentication and per-user cookies.
+
+Only one set of tests is needed, switching from internal to external is
+achieved through environment variables.
+
+![Status](https://github.com/zx80/flask-tester/actions/workflows/package.yml/badge.svg?branch=main&style=flat)
+![Tests](https://img.shields.io/badge/tests-13%20✓-success)
+![Coverage](https://img.shields.io/badge/coverage-100%25-success)
+![Issues](https://img.shields.io/github/issues/zx80/flask-tester?style=flat)
+![Python](https://img.shields.io/badge/python-3-informational)
+![Version](https://img.shields.io/pypi/v/FlaskTester)
+![Badges](https://img.shields.io/badge/badges-8-informational)
+![License](https://img.shields.io/pypi/l/flasktester?style=flat)
+
+## Usage
+
+Install package with `pip install FlaskTester` or equivalent.
+
+The following test creates a local fixture with 2 users identified by a
+password, and retrieves tokens for both users using a `/login` route
+provided by the application.
+It then proceeds to run authenticated requests against the `/admin` route.
+
+```python
+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 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"])
+    # also set a cookie
+    ft_client.setCookie("hobbes", "lang", "fr")
+    ft_client.setCookie("calvin", "lang", "en")
+    # return working client
+    yield ft_client
+
+def test_app_admin(app):
+    app.get("/admin", login=None, status=401)
+    for auth in ["bearer", "basic", "param"]:
+        res = app.get("/admin", login="calvin", auth=auth, status=200)
+        assert res.json["user"] == "calvin" and res.json["isadmin"]
+        res = app.get("/admin", login="hobbes", auth=auth, 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 test seed
+flask --app app:app run &                        # start flask app
+pid=$!                                           # keep pid
+export FLASK_TESTER_URL="http://localhost:5000"  # set app local url
+pytest test.py                                   # run external tests
+kill $pid                                        # stop app with pid
+```
+
+Or locally with the Flask internal test infrastructure:
+
+```shell
+export FLASK_TESTER_APP="app:app"                # set app module
+pytest test.py                                   # run internal tests
+```
+
+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
+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
+translation service.
+
+See the [documentation](https://zx80.github.io/flask-tester/).
+
+## License
+
+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,
+please report any [issues](https://github.com/zx80/flask-tester/issues).

{FlaskTester-3.3 → FlaskTester-3.5}/FlaskTester.egg-info/requires.txt

@@ -13,7 +13,7 @@ twine
 wheel
 types-flask
 types-requests
-FlaskSimpleAuth>=29.5
+FlaskSimpleAuth>=30.0
 passlib
 
 [doc]

{FlaskTester-3.3 → FlaskTester-3.5}/FlaskTester.py

@@ -1,6 +1,6 @@
 """FlaskTester - Pytest fixtures for Flask authenticated internal and external tests.
 
-Pytest: PYTEST_DONT_REWRITE
+PYTEST_DONT_REWRITE: local assertions are really that, not pytest assertions.
 """
 
 import os
@@ -24,38 +24,56 @@ class AuthError(FlaskTesterError):
     pass
 
 
+class _AssertError(FlaskTesterError):
+    """User assertion Exception, only for internal testing."""
+    pass
+
+
+def _raiseError(msg: str):
+    """Undocumented switch for FlaskTester own tests."""
+    log.error(msg)
+    if "FLASK_TESTER_TESTING" in os.environ:
+        raise _AssertError(msg)
+    else:  # pragma: no cover  # cannot cover an expected pytest failure!
+        pytest.fail(msg)
+
+
 class Authenticator:
-    """Manage authentication for test requests.
+    """Manage HTTP request authentication.
 
     Supported schemes:
 
-    - ``basic``: HTTP Basic Authentication
-    - ``param``: password with HTTP or JSON parameters
-    - ``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
-    - ``none``: no authentication, only cookies
+    - ``basic``: HTTP Basic Authentication.
+    - ``param``: password with HTTP or JSON parameters.
+    - ``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.
+    - ``none``: no authentication, only cookies.
 
     Constructor parameters:
 
     - ``allow``: list of allowed schemes.
-      default is ``["bearer", "basic", "param", "none"]``
+      default is ``["bearer", "basic", "param", "none"]``.
     - ``user``: parameter for user on ``param`` password authentication,
-      default is ``USER``
+      default is ``USER``.
     - ``pwd``: parameter for password on ``param`` password authentication,
-      default is ``PASS``
+      default is ``PASS``.
     - ``login``: parameter for user on ``fake`` authentication,
-      default is ``LOGIN``
+      default is ``LOGIN``.
     - ``bearer``: name of bearer scheme for token,
-      default is ``Bearer``
+      default is ``Bearer``.
     - ``header``: name of header for token,
-      default is ``Auth``
+      default is ``Auth``.
     - ``cookie``: name of cookie for token,
-      default is ``auth``
+      default is ``auth``.
     - ``tparam``: name of parameter for token,
-      default is ``AUTH``
+      default is ``AUTH``.
+    - ``ptype``: default parameter type, either ``data`` or ``json``,
+      default is ``data``.
+
+    Note: default values are consistent with `FlaskSimpleAuth <https://pypi.org/project/FlaskSimpleAuth/>`_.
     """
 
     _TOKEN_SCHEMES = {"bearer", "header", "cookie", "tparam"}
@@ -78,6 +96,7 @@ class Authenticator:
              header: str = "Auth",
              cookie: str = "auth",
              tparam: str = "AUTH",
+             ptype: str = "data",
          ):
 
         self._has_pass, self._has_token = False, False
@@ -97,6 +116,8 @@ class Authenticator:
         self._header = header
         self._cookie = cookie
         self._tparam = tparam
+        assert ptype in ("json", "data")
+        self._ptype = ptype
 
         # password and token credentials, cookies
         self._passes: dict[str, str] = {}
@@ -122,7 +143,7 @@ class Authenticator:
         self._set(login, pw, self._passes)
 
     def setPasses(self, pws: list[str]):
-        """Associate a list of login:password."""
+        """Associate a list of *login:password*."""
         for lp in pws:
             login, pw = lp.split(":", 1)
             self.setPass(login, pw)
@@ -143,7 +164,7 @@ class Authenticator:
         self._set(name, val, self._cookies[login])
 
     def _param(self, kwargs: dict[str, Any], key: str, val: Any):
-        """Add request parameter to "json" or "data"."""
+        """Add request parameter to ``json`` or ``data``."""
 
         if "json" in kwargs:
             assert isinstance(kwargs["json"], dict)
@@ -152,7 +173,7 @@ class Authenticator:
             assert isinstance(kwargs["data"], dict)
             kwargs["data"][key] = val
         else:
-            kwargs["data"] = {key: val}
+            kwargs[self._ptype] = {key: val}
 
     def _try_auth(self, auth: str|None, scheme: str) -> bool:
         """Whether to try this authentication scheme."""
@@ -161,10 +182,10 @@ 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
+        - ``login``: login target, None means no authentication.
+        - ``kwargs``: request parameters.
+        - ``cookies``: request cookies.
+        - ``auth``: authentication method, default is None.
 
         The default behavior is to try allowed schemes: tokens first,
         then password, then fake.
@@ -234,13 +255,13 @@ class RequestFlaskResponse:
 
     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:
 
@@ -268,8 +289,8 @@ class Client:
 
     Constructor parameters:
 
-    - ``auth`` authenticator
-    - ``default_login`` if ``login`` is not set.
+    - ``auth``: authenticator.
+    - ``default_login``: if ``login`` is not set.
     """
 
     def __init__(self, auth: Authenticator, default_login: str|None = None):
@@ -299,16 +320,16 @@ class Client:
 
         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
-        - ``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…)
+        - ``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…).
         """
 
         if "login" in kwargs:
@@ -328,43 +349,37 @@ class Client:
         # check status
         if status is not None:
             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, f"unexpected status {res.status_code}, expecting {status}"
+                _raiseError(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):
-                log.error(f"cannot find {content} in {res.text}")
-                assert False, f"expected content {content} not found in {res.text}"
+                _raiseError(f"cannot find {content} in {res.text[:512]}...")
 
         return res
 
-    def get(self, path, **kwargs):
-        """HTTP GET request."""
-        return self.request("GET", path, **kwargs)
+    def get(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
+        """HTTP GET request, see ``request`` parameters."""
+        return self.request("GET", path, status=status, content=content, **kwargs)
 
-    def post(self, path, **kwargs):
-        """HTTP POST request."""
-        return self.request("POST", path, **kwargs)
+    def post(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
+        """HTTP POST request, see ``request`` parameters."""
+        return self.request("POST", path, status=status, content=content, **kwargs)
 
-    def put(self, path, **kwargs):
-        """HTTP PUT request."""
-        return self.request("PUT", path, **kwargs)
+    def put(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
+        """HTTP PUT request, see ``request`` parameters."""
+        return self.request("PUT", path, status=status, content=content, **kwargs)
 
-    def patch(self, path, **kwargs):
-        """HTTP PATCH request."""
-        return self.request("PATCH", path, **kwargs)
+    def patch(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
+        """HTTP PATCH request, see ``request`` parameters."""
+        return self.request("PATCH", path, status=status, content=content, **kwargs)
 
-    def delete(self, path, **kwargs):
-        """HTTP DELETE request."""
-        return self.request("DELETE", path, **kwargs)
+    def delete(self, path: str, status: int|None = None, content: str|None = None, **kwargs):
+        """HTTP DELETE request, see ``request`` parameters."""
+        return self.request("DELETE", path, status=status, content=content, **kwargs)
 
     def check(self, method: str, path: str, status: int, content: str|None = None, **kwargs):
-        """Run a query and check the response status.
-
-        Same as ``request``, but ``status`` is mandatory.
-        """
-
+        """Deprecated, use ``request`` or HTTP-method-specific methods."""
         return self.request(method, path, status=status, content=content, **kwargs)
 
 
@@ -373,9 +388,9 @@ class RequestClient(Client):
 
     Constructor parameters:
 
-    - ``auth`` authenticator
-    - ``base_url`` target server
-    - ``default_login`` if ``login`` is not set.
+    - ``auth``: authenticator.
+    - ``base_url``: target server.
+    - ``default_login``: if ``login`` is not set.
     """
 
     def __init__(self, auth: Authenticator, base_url: str, default_login=None):
@@ -419,9 +434,9 @@ class FlaskClient(Client):
 
     Constructor parameters:
 
-    - ``auth`` authenticator
-    - ``client`` Flask actual ``test_client``
-    - ``default_login`` if ``login`` is not set.
+    - ``auth``: authenticator.
+    - ``client``: Flask actual ``test_client``.
+    - ``default_login``: if ``login`` is not set.
 
     Note: this client handles `cookies`.
     """
@@ -446,7 +461,7 @@ class FlaskClient(Client):
         return self._client.open(method=method, path=path, **kwargs)
 
 def _ft_authenticator():
-    """Fixture implementation separated for testing."""
+    """Fixture implementation, separated for testing purposes."""
 
     level = os.environ.get("FLASK_TESTER_LOG_LEVEL", "NOTSET")
     log.setLevel(logging.DEBUG if level == "DEBUG" else
@@ -466,9 +481,11 @@ def _ft_authenticator():
     header = os.environ.get("FLASK_TESTER_HEADER", "Auth")
     cookie = os.environ.get("FLASK_TESTER_COOKIE", "auth")
     tparam = os.environ.get("FLASK_TESTER_TPARAM", "AUTH")
+    ptype = os.environ.get("FLASK_TESTER_PTYPE", "data")
 
     # create authenticator, possibly with initial credentials
-    auth = Authenticator(allow, user=user, pwd=pwd, login=login, bearer=bearer, header=header, cookie=cookie, tparam=tparam)
+    auth = Authenticator(allow, user=user, pwd=pwd, login=login, bearer=bearer,
+                         header=header, cookie=cookie, tparam=tparam, ptype=ptype)
 
     if "FLASK_TESTER_AUTH" in os.environ:
         auth.setPasses(os.environ["FLASK_TESTER_AUTH"].split(","))
@@ -501,6 +518,8 @@ def ft_authenticator():
       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.
     """
@@ -550,7 +569,7 @@ def ft_client(ft_authenticator):
 
     Target environment variable, one **must** be defined:
 
-    - ``FLASK_TESTER_URL``: application HTTP base URL.
+    - ``FLASK_TESTER_URL``: application HTTP base URL, eg ``http://localhost:5000``.
     - ``FLASK_TESTER_APP``: Flask application, eg ``app:create_app``.
 
     Other environment variable:

FlaskTester-3.5/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.1
+Name: FlaskTester
+Version: 3.5
+Summary: Pytest fixtures for Flask internal and external authenticated tests
+Author-email: Fabien Coelho <flask.tester@coelho.net>
+License: CC0
+Project-URL: repository, https://github.com/zx80/flask-tester
+Project-URL: documentation, https://zx80.github.io/flask-tester/
+Project-URL: issues, https://github.com/zx80/flask-tester/issues
+Project-URL: package, https://pypi.org/project/FlaskTester/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+Classifier: Programming Language :: Python
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Flask
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: flask
+Requires-Dist: pytest
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: pymarkdownlnt!=0.9.5; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: types-flask; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: FlaskSimpleAuth>=30.0; extra == "dev"
+Requires-Dist: passlib; extra == "dev"
+Provides-Extra: doc
+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
+
+This package allows to run authenticated tests against a Flask application,
+either with internal Flask tests (aka `test_client`) or external tests (with
+`requests` which performs actual HTTP requests), including password and token
+authentication and per-user cookies.
+
+Only one set of tests is needed, switching from internal to external is
+achieved through environment variables.
+
+![Status](https://github.com/zx80/flask-tester/actions/workflows/package.yml/badge.svg?branch=main&style=flat)
+![Tests](https://img.shields.io/badge/tests-13%20✓-success)
+![Coverage](https://img.shields.io/badge/coverage-100%25-success)
+![Issues](https://img.shields.io/github/issues/zx80/flask-tester?style=flat)
+![Python](https://img.shields.io/badge/python-3-informational)
+![Version](https://img.shields.io/pypi/v/FlaskTester)
+![Badges](https://img.shields.io/badge/badges-8-informational)
+![License](https://img.shields.io/pypi/l/flasktester?style=flat)
+
+## Usage
+
+Install package with `pip install FlaskTester` or equivalent.
+
+The following test creates a local fixture with 2 users identified by a
+password, and retrieves tokens for both users using a `/login` route
+provided by the application.
+It then proceeds to run authenticated requests against the `/admin` route.
+
+```python
+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 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"])
+    # also set a cookie
+    ft_client.setCookie("hobbes", "lang", "fr")
+    ft_client.setCookie("calvin", "lang", "en")
+    # return working client
+    yield ft_client
+
+def test_app_admin(app):
+    app.get("/admin", login=None, status=401)
+    for auth in ["bearer", "basic", "param"]:
+        res = app.get("/admin", login="calvin", auth=auth, status=200)
+        assert res.json["user"] == "calvin" and res.json["isadmin"]
+        res = app.get("/admin", login="hobbes", auth=auth, 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 test seed
+flask --app app:app run &                        # start flask app
+pid=$!                                           # keep pid
+export FLASK_TESTER_URL="http://localhost:5000"  # set app local url
+pytest test.py                                   # run external tests
+kill $pid                                        # stop app with pid
+```
+
+Or locally with the Flask internal test infrastructure:
+
+```shell
+export FLASK_TESTER_APP="app:app"                # set app module
+pytest test.py                                   # run internal tests
+```
+
+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
+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
+translation service.
+
+See the [documentation](https://zx80.github.io/flask-tester/).
+
+## License
+
+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,
+please report any [issues](https://github.com/zx80/flask-tester/issues).