FlaskTester 3.0__tar.gz → 3.2__tar.gz

{FlaskTester-3.0 → FlaskTester-3.2}/FlaskTester.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FlaskTester
-Version: 3.0
+Version: 3.2
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
 License: CC0
@@ -46,13 +46,13 @@ Requires-Dist: myst_parser; extra == "doc"
 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.
+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-11%20✓-success)
+![Tests](https://img.shields.io/badge/tests-12%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)
@@ -87,8 +87,8 @@ def app(ft_client):
     assert res.is_json
     ft_client.setToken("hobbes", res.json["token"])
     # also set a cookie
-    ft_client.setCookie("hobbes", "lang", "fr_FR")
-    ft_client.setCookie("calvin", "lang", "en_EN")
+    ft_client.setCookie("hobbes", "lang", "fr")
+    ft_client.setCookie("calvin", "lang", "en")
     # return working client
     yield ft_client
 
@@ -109,7 +109,7 @@ def test_app_admin(app):
 This can be run against a (local) server:
 
 ```shell
-export TEST_SEED="some-random-data"              # shared seed
+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
@@ -128,6 +128,11 @@ 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.
 
 ## Fixtures
 
@@ -155,11 +160,12 @@ The package provides two fixtures:
   - `FLASK_TESTER_LOG_LEVEL` log level for module,
     default is `NOTSET`.
 
-  The fixture has 3 main methods:
+  The fixture has 4 main methods:
   - `setPass` to associate a password to a user, set to _None_ to remove credential.
   - `setToken` to associate a token to a user, set to _None_ to remove credential.
   - `setCookie` to add a cookie to a user, set value to _None_ to remove cookie.
-  - `setAuth` to add authentication data to a request `kwargs` and `cookies`.
+  - `setAuth` to add authentication data to a request `kwargs` and `cookies`.  
+    This method is called automatically for adding credentials to a request.
 
 - `ft_client` for app testing, which depends on the previous fixture, plus
   environment variables which allow to find the application, at least one must
@@ -178,7 +184,7 @@ The package provides two fixtures:
 
   The fixture then provides test methods to issue test requests against a Flask application:
   - `request` generic request with `login`, `auth`, `status` end `content` extensions.
-  - `get post put patch delete` methods with `login`, `auth` and `status` extensions.
+  - `get post put patch delete` methods with `login`, `auth` and `status` extensions.  
   Moreover, `setPass`, `setToken` and `setCookie` are forwarded to the internal authenticator.
 
 Authenticator environment variables can be set from the pytest Python test file by
@@ -242,6 +248,17 @@ Packages are distributed from [PyPI](https://pypi.org/project/FlaskTester/),
 see also the [documentation](https://zx80.github.io/flask-tester/),
 please report any [issues](https://github.com/zx80/flask-tester/issues).
 
+### 3.2 on 2024-03-24
+
+Improved documentation.
+Simpler code and API documentation.
+
+### 3.1 on 2024-03-24
+
+More consistent test and demo code.
+Reach actual full coverage, without _any_ pragma.
+Fix default allowed authenticator schemes.
+
 ### 3.0 on 2024-03-23
 
 Add support for `none` authentication, with only cookies.

{FlaskTester-3.0 → FlaskTester-3.2}/FlaskTester.py

@@ -293,7 +293,8 @@ class Client:
         """Run a request and return response."""
         raise NotImplementedError()
 
-    def request(self, method: str, path: str, status: int|None = None, auth: str|None = None, **kwargs):
+    def request(self, method: str, path: str, status: int|None = None, content: str|None = None,
+                auth: str|None = None, **kwargs):
         """Run a possibly authenticated HTTP request.
 
         Mandatory parameters:
@@ -304,6 +305,7 @@ class Client:
         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…)
@@ -323,11 +325,18 @@ class Client:
         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
                 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}"
 
+        # 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}"
+
         return res
 
     def get(self, path, **kwargs):
@@ -350,32 +359,13 @@ class Client:
         """HTTP DELETE request."""
         return self.request("DELETE", path, **kwargs)
 
-    def check(self, method: str, path: str, status: int, content: str|None = None, **kwargs):
-        """Run a query and check the response.
-
-        Mandatory parameters:
+    def check(self, method: str, path: str, status: int, **kwargs):
+        """Run a query and check the response 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…)
+        Same as ``request``, but ``status`` is mandatory.
         """
 
-        # get HTTP response
-        res = self.request(method, path, status=status, **kwargs)
-
-        # check contents
-        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}"
-
-        return res
+        return self.request(method, path, status=status, **kwargs)
 
 
 class RequestClient(Client):
@@ -455,36 +445,8 @@ class FlaskClient(Client):
 
         return self._client.open(method=method, path=path, **kwargs)
 
-
-@pytest.fixture
-def ft_authenticator():
-    """Pytest Fixture: ft_authenticator.
-
-    Environment variables:
-
-    - ``FLASK_TESTER_LOG_LEVEL``: package log level in
-      ``DEBUG INFO WARNING ERROR CRITICAL NOSET``.
-      Default is ``NOTSET``.
-    - ``FLASK_TESTER_ALLOW``: allowed space-separated authentication schemes, in
-      ``basic param bearer header cookie tparam fake none``.
-      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*.
-      Default is not set.
-    """
+def _ft_authenticator():
+    """Fixture implementation separated for testing."""
 
     level = os.environ.get("FLASK_TESTER_LOG_LEVEL", "NOTSET")
     log.setLevel(logging.DEBUG if level == "DEBUG" else
@@ -494,7 +456,7 @@ def ft_authenticator():
                  logging.CRITICAL if level == "CRITICAL" else
                  logging.NOTSET)
 
-    allow = os.environ.get("FLASK_TESTER_ALLOW", "bearer basic param").split(" ")
+    allow = os.environ.get("FLASK_TESTER_ALLOW", "bearer basic param none").split(" ")
 
     # per-scheme parameters, must be consistent with FSA configuration
     user = os.environ.get("FLASK_TESTER_USER", "USER")
@@ -511,31 +473,50 @@ def ft_authenticator():
     if "FLASK_TESTER_AUTH" in os.environ:
         auth.setPasses(os.environ["FLASK_TESTER_AUTH"].split(","))
 
-    yield auth
-
+    return auth
 
 @pytest.fixture
-def ft_client(ft_authenticator):
-    """Pytest Fixture: ft_client.
+def ft_authenticator():
+    """Pytest Fixture: ft_authenticator.
 
-    Target environment variable, one **must** be defined:
+    Environment variables:
 
-    - ``FLASK_TESTER_URL``: application HTTP base URL.
-    - ``FLASK_TESTER_APP``: Flask application, eg ``app:create_app``.
+    - ``FLASK_TESTER_LOG_LEVEL``: package log level in
+      ``DEBUG INFO WARNING ERROR CRITICAL NOSET``.
+      Default is ``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_AUTH``: initial comma-separated list of *login:password*.
+      Default is not set.
+    """
 
-    Other environment variable:
+    yield _ft_authenticator()
 
-    - ``FLASK_TESTER_DEFAULT``: Default client login, default is *None* for no
-      default.
-    """
+def _ft_client(authenticator):
+    """Fixture implementation separated for testing."""
 
     default_login = os.environ.get("FLASK_TESTER_DEFAULT", None)
     client: Client
 
-    if "FLASK_TESTER_URL" in os.environ:  # pragma: no cover
+    if "FLASK_TESTER_URL" in os.environ:
 
         app_url = os.environ["FLASK_TESTER_URL"]
-        client = RequestClient(ft_authenticator, app_url, default_login)
+        client = RequestClient(authenticator, app_url, default_login)
 
     elif "FLASK_TESTER_APP" in os.environ:
 
@@ -553,12 +534,29 @@ def ft_client(ft_authenticator):
                 if callable(app) and not hasattr(app, "test_client"):
                     app = app()
                 break
-        if not app:  # pragma: no cover
+        if not app:
             raise FlaskTesterError(f"cannot find Flask app in {pkg_name}")
-        client = FlaskClient(ft_authenticator, app.test_client(), default_login)
+        client = FlaskClient(authenticator, app.test_client(), default_login)
 
-    else:  # pragma: no cover
+    else:
 
         raise FlaskTesterError("no Flask application to test")
 
-    yield client
+    return client
+
+@pytest.fixture
+def ft_client(ft_authenticator):
+    """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.
+    """
+
+    yield _ft_client(ft_authenticator)

{FlaskTester-3.0 → FlaskTester-3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FlaskTester
-Version: 3.0
+Version: 3.2
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
 License: CC0
@@ -46,13 +46,13 @@ Requires-Dist: myst_parser; extra == "doc"
 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.
+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-11%20✓-success)
+![Tests](https://img.shields.io/badge/tests-12%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)
@@ -87,8 +87,8 @@ def app(ft_client):
     assert res.is_json
     ft_client.setToken("hobbes", res.json["token"])
     # also set a cookie
-    ft_client.setCookie("hobbes", "lang", "fr_FR")
-    ft_client.setCookie("calvin", "lang", "en_EN")
+    ft_client.setCookie("hobbes", "lang", "fr")
+    ft_client.setCookie("calvin", "lang", "en")
     # return working client
     yield ft_client
 
@@ -109,7 +109,7 @@ def test_app_admin(app):
 This can be run against a (local) server:
 
 ```shell
-export TEST_SEED="some-random-data"              # shared seed
+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
@@ -128,6 +128,11 @@ 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.
 
 ## Fixtures
 
@@ -155,11 +160,12 @@ The package provides two fixtures:
   - `FLASK_TESTER_LOG_LEVEL` log level for module,
     default is `NOTSET`.
 
-  The fixture has 3 main methods:
+  The fixture has 4 main methods:
   - `setPass` to associate a password to a user, set to _None_ to remove credential.
   - `setToken` to associate a token to a user, set to _None_ to remove credential.
   - `setCookie` to add a cookie to a user, set value to _None_ to remove cookie.
-  - `setAuth` to add authentication data to a request `kwargs` and `cookies`.
+  - `setAuth` to add authentication data to a request `kwargs` and `cookies`.  
+    This method is called automatically for adding credentials to a request.
 
 - `ft_client` for app testing, which depends on the previous fixture, plus
   environment variables which allow to find the application, at least one must
@@ -178,7 +184,7 @@ The package provides two fixtures:
 
   The fixture then provides test methods to issue test requests against a Flask application:
   - `request` generic request with `login`, `auth`, `status` end `content` extensions.
-  - `get post put patch delete` methods with `login`, `auth` and `status` extensions.
+  - `get post put patch delete` methods with `login`, `auth` and `status` extensions.  
   Moreover, `setPass`, `setToken` and `setCookie` are forwarded to the internal authenticator.
 
 Authenticator environment variables can be set from the pytest Python test file by
@@ -242,6 +248,17 @@ Packages are distributed from [PyPI](https://pypi.org/project/FlaskTester/),
 see also the [documentation](https://zx80.github.io/flask-tester/),
 please report any [issues](https://github.com/zx80/flask-tester/issues).
 
+### 3.2 on 2024-03-24
+
+Improved documentation.
+Simpler code and API documentation.
+
+### 3.1 on 2024-03-24
+
+More consistent test and demo code.
+Reach actual full coverage, without _any_ pragma.
+Fix default allowed authenticator schemes.
+
 ### 3.0 on 2024-03-23
 
 Add support for `none` authentication, with only cookies.

{FlaskTester-3.0 → FlaskTester-3.2}/README.md

@@ -3,13 +3,13 @@
 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.
+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-11%20✓-success)
+![Tests](https://img.shields.io/badge/tests-12%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)
@@ -44,8 +44,8 @@ def app(ft_client):
     assert res.is_json
     ft_client.setToken("hobbes", res.json["token"])
     # also set a cookie
-    ft_client.setCookie("hobbes", "lang", "fr_FR")
-    ft_client.setCookie("calvin", "lang", "en_EN")
+    ft_client.setCookie("hobbes", "lang", "fr")
+    ft_client.setCookie("calvin", "lang", "en")
     # return working client
     yield ft_client
 
@@ -66,7 +66,7 @@ def test_app_admin(app):
 This can be run against a (local) server:
 
 ```shell
-export TEST_SEED="some-random-data"              # shared seed
+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
@@ -85,6 +85,11 @@ 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.
 
 ## Fixtures
 
@@ -112,11 +117,12 @@ The package provides two fixtures:
   - `FLASK_TESTER_LOG_LEVEL` log level for module,
     default is `NOTSET`.
 
-  The fixture has 3 main methods:
+  The fixture has 4 main methods:
   - `setPass` to associate a password to a user, set to _None_ to remove credential.
   - `setToken` to associate a token to a user, set to _None_ to remove credential.
   - `setCookie` to add a cookie to a user, set value to _None_ to remove cookie.
-  - `setAuth` to add authentication data to a request `kwargs` and `cookies`.
+  - `setAuth` to add authentication data to a request `kwargs` and `cookies`.  
+    This method is called automatically for adding credentials to a request.
 
 - `ft_client` for app testing, which depends on the previous fixture, plus
   environment variables which allow to find the application, at least one must
@@ -135,7 +141,7 @@ The package provides two fixtures:
 
   The fixture then provides test methods to issue test requests against a Flask application:
   - `request` generic request with `login`, `auth`, `status` end `content` extensions.
-  - `get post put patch delete` methods with `login`, `auth` and `status` extensions.
+  - `get post put patch delete` methods with `login`, `auth` and `status` extensions.  
   Moreover, `setPass`, `setToken` and `setCookie` are forwarded to the internal authenticator.
 
 Authenticator environment variables can be set from the pytest Python test file by
@@ -199,6 +205,17 @@ Packages are distributed from [PyPI](https://pypi.org/project/FlaskTester/),
 see also the [documentation](https://zx80.github.io/flask-tester/),
 please report any [issues](https://github.com/zx80/flask-tester/issues).
 
+### 3.2 on 2024-03-24
+
+Improved documentation.
+Simpler code and API documentation.
+
+### 3.1 on 2024-03-24
+
+More consistent test and demo code.
+Reach actual full coverage, without _any_ pragma.
+Fix default allowed authenticator schemes.
+
 ### 3.0 on 2024-03-23
 
 Add support for `none` authentication, with only cookies.

{FlaskTester-3.0 → FlaskTester-3.2}/pyproject.toml

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

{FlaskTester-3.0 → FlaskTester-3.2}/tests/test.py

@@ -38,8 +38,8 @@ def app(ft_client):
     assert res.is_json
     ft_client.setToken("hobbes", res.json["token"])
     # also set a cookie
-    ft_client.setCookie("hobbes", "lang", "fr_FR")
-    ft_client.setCookie("calvin", "lang", "en_EN")
+    ft_client.setCookie("hobbes", "lang", "fr")
+    ft_client.setCookie("calvin", "lang", "en")
     # return working client
     yield ft_client
 
@@ -136,16 +136,16 @@ def test_methods(api):
 
 def test_hello(api):
     res = api.get("/hello", login="calvin", auth="none", status=200)
-    assert res.json["hello"] == "Hi"
+    assert res.json["lang"] == "en" and res.json["hello"] == "Hi"
     assert res.headers["FSA-User"] == "None (None)"
     res = api.get("/hello", login="hobbes", auth="none", status=200)
-    assert res.json["hello"] == "Salut"
+    assert res.json["lang"] == "fr" and res.json["hello"] == "Salut"
     assert res.headers["FSA-User"] == "None (None)"
     res = api.get("/hello", login="susie", auth="none", status=200, cookies={"lang": "it"})
-    assert res.json["hello"] == "Ciao"
+    assert res.json["lang"] == "it" and res.json["hello"] == "Ciao"
     assert res.headers["FSA-User"] == "None (None)"
     res = api.get("/hello", login="moe", auth="none", status=200)
-    assert res.json["hello"] == "Hi"
+    assert res.json["lang"] == "en" and res.json["hello"] == "Hi"
     assert res.headers["FSA-User"] == "None (None)"
 
 def test_authenticator_token():
@@ -269,6 +269,7 @@ def test_request_flask_response():
     assert not xres.is_json and xres.json is None
 
 def test_client():
+    # abstract class for coverage
     client = ft.Client(ft.Authenticator())
     try:
         client._request("GET", "/", {})
@@ -277,6 +278,7 @@ def test_client():
         assert True, "expected error raised"
 
 def test_request_client():
+    # start a tmp server on port 8888 for URL client coverage
     httpd = htsv.HTTPServer(("", 8888), htsv.SimpleHTTPRequestHandler)
     thread = threading.Thread(target = lambda: httpd.serve_forever())
     thread.start()
@@ -290,3 +292,48 @@ def test_request_client():
         client.post("/", status=501, data={"hello": "world!"})
     finally:
         httpd.shutdown()
+
+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"
+    # url
+    os.environ["FLASK_TESTER_URL"] = "http://localhost:5000"
+    init = ft._ft_client(auth)
+    assert isinstance(init, ft.RequestClient)
+    del os.environ["FLASK_TESTER_URL"]
+    # bad package
+    os.environ["FLASK_TESTER_APP"] = "no_such_package"
+    try:
+        init = ft._ft_client(auth)
+        pytest.fail("must fail on missing package")  # pragma: no cover
+    except ModuleNotFoundError:
+        assert True, "expected error raised"
+    # bad name
+    os.environ["FLASK_TESTER_APP"] = "app:no_such_app"
+    try:
+        init = ft._ft_client(auth)
+        pytest.fail("must fail on missing package")  # pragma: no cover
+    except ft.FlaskTesterError:
+        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