FlaskTester 3.5__tar.gz → 4.0__tar.gz

{FlaskTester-3.5 → flasktester-4.0}/FlaskTester.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FlaskTester
-Version: 3.5
+Version: 4.0
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
 License: CC0
@@ -49,10 +49,10 @@ 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-13%20✓-success)
+![Tests](https://img.shields.io/badge/tests-14%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)
@@ -107,7 +107,7 @@ This can be run against a (local) server:
 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
+export FLASK_TESTER_APP="http://localhost:5000"  # set app local url
 pytest test.py                                   # run external tests
 kill $pid                                        # stop app with pid
 ```
@@ -115,7 +115,7 @@ kill $pid                                        # stop app with pid
 Or locally with the Flask internal test infrastructure:
 
 ```shell
-export FLASK_TESTER_APP="app:app"                # set app module
+export FLASK_TESTER_APP="app:app"                # set app package
 pytest test.py                                   # run internal tests
 ```
 

{FlaskTester-3.5 → flasktester-4.0}/FlaskTester.egg-info/SOURCES.txt

@@ -8,4 +8,5 @@ FlaskTester.egg-info/SOURCES.txt
 FlaskTester.egg-info/dependency_links.txt
 FlaskTester.egg-info/requires.txt
 FlaskTester.egg-info/top_level.txt
-tests/test.py
+tests/test_app.py
+tests/test_app2.py

{FlaskTester-3.5 → flasktester-4.0}/FlaskTester.py

@@ -29,12 +29,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 +57,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 +185,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 +254,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 +268,7 @@ class RequestFlaskResponse:
 
     Constructor parameter:
 
-    - ``response``: from request.
+    :param response: Response from request.
     """
 
     def __init__(self, response):
@@ -289,8 +292,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 +323,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:
@@ -349,48 +352,44 @@ class Client:
         # 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]}...")
+                _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]}...")
+                _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 +433,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 +498,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,45 +531,43 @@ def _ft_client(authenticator):
     default_login = os.environ.get("FLASK_TESTER_DEFAULT", None)
     client: Client
 
-    if "FLASK_TESTER_URL" in os.environ:
-
-        app_url = os.environ["FLASK_TESTER_URL"]
-        client = RequestClient(authenticator, app_url, default_login)
-
-    elif "FLASK_TESTER_APP" in os.environ:
+    test_app = os.environ.get("FLASK_TESTER_APP", "app")
 
+    if test_app.startswith("http://") or test_app.startswith("https://"):
+        client = RequestClient(authenticator, test_app, default_login)
+    else:
         # load app package
-        pkg_name, app = os.environ["FLASK_TESTER_APP"], 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)
 
-    else:
-
-        raise FlaskTesterError("no Flask application to test")
-
     return client
 
 @pytest.fixture
 def ft_client(ft_authenticator):
     """Pytest Fixture: ft_client.
 
-    Target environment variable, one **must** be defined:
+    Mandatory target environment variable:
 
-    - ``FLASK_TESTER_URL``: application HTTP base URL, eg ``http://localhost:5000``.
-    - ``FLASK_TESTER_APP``: Flask application, eg ``app:create_app``.
+    - ``FLASK_TESTER_APP``: find the Flask application, eg
+      ``app:create_app`` for an internal test, or
+      ``http://localhost:5000`` for an external test.
 
     Other environment variable:
 

{FlaskTester-3.5 → flasktester-4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FlaskTester
-Version: 3.5
+Version: 4.0
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
 License: CC0
@@ -49,10 +49,10 @@ 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-13%20✓-success)
+![Tests](https://img.shields.io/badge/tests-14%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)
@@ -107,7 +107,7 @@ This can be run against a (local) server:
 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
+export FLASK_TESTER_APP="http://localhost:5000"  # set app local url
 pytest test.py                                   # run external tests
 kill $pid                                        # stop app with pid
 ```
@@ -115,7 +115,7 @@ kill $pid                                        # stop app with pid
 Or locally with the Flask internal test infrastructure:
 
 ```shell
-export FLASK_TESTER_APP="app:app"                # set app module
+export FLASK_TESTER_APP="app:app"                # set app package
 pytest test.py                                   # run internal tests
 ```
 

{FlaskTester-3.5 → flasktester-4.0}/README.md

@@ -6,10 +6,10 @@ 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-13%20✓-success)
+![Tests](https://img.shields.io/badge/tests-14%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)
@@ -64,7 +64,7 @@ This can be run against a (local) server:
 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
+export FLASK_TESTER_APP="http://localhost:5000"  # set app local url
 pytest test.py                                   # run external tests
 kill $pid                                        # stop app with pid
 ```
@@ -72,7 +72,7 @@ kill $pid                                        # stop app with pid
 Or locally with the Flask internal test infrastructure:
 
 ```shell
-export FLASK_TESTER_APP="app:app"                # set app module
+export FLASK_TESTER_APP="app:app"                # set app package
 pytest test.py                                   # run internal tests
 ```
 

{FlaskTester-3.5 → flasktester-4.0}/pyproject.toml

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

FlaskTester-3.5/tests/test.py → flasktester-4.0/tests/test_app.py

@@ -22,7 +22,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 +296,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,26 +309,17 @@ def test_client_fixture():
     # ft_client coverage
     auth = ft._ft_authenticator()
     # check and save env
-    # assert "FLASK_TESTER_URL" not in os.environ
-    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"]
         del os.environ["FLASK_TESTER_APP"]
-    # no url nor app
-    try:
-        init = ft._ft_client(auth)
-        pytest.fail("must fail without environment variables")  # pragma: no cover
-    except ft.FlaskTesterError:
-        assert True, "expected error raised"
+    # 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:
@@ -345,7 +336,5 @@ 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

flasktester-4.0/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)