FlaskTester 5.0__tar.gz → 6.0__tar.gz

{flasktester-5.0 → flasktester-6.0}/FlaskTester.egg-info/PKG-INFO

@@ -1,16 +1,15 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: FlaskTester
-Version: 5.0
+Version: 6.0
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
-License: CC0
+License-Expression: CC0-1.0
 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
@@ -26,6 +25,7 @@ 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: flake8; extra == "dev"
 Requires-Dist: types-flask; extra == "dev"
 Requires-Dist: types-requests; extra == "dev"
 Requires-Dist: FlaskSimpleAuth>=35.0; extra == "dev"
@@ -41,6 +41,7 @@ Provides-Extra: pub
 Requires-Dist: build; extra == "pub"
 Requires-Dist: twine; extra == "pub"
 Requires-Dist: wheel; extra == "pub"
+Dynamic: license-file
 
 # FlaskTester - Pytest fixtures for Flask internal and external authenticated tests
 

{flasktester-5.0 → flasktester-6.0}/FlaskTester.egg-info/SOURCES.txt

@@ -7,6 +7,4 @@ FlaskTester.egg-info/PKG-INFO
 FlaskTester.egg-info/SOURCES.txt
 FlaskTester.egg-info/dependency_links.txt
 FlaskTester.egg-info/requires.txt
-FlaskTester.egg-info/top_level.txt
-tests/test_app.py
-tests/test_app2.py
+FlaskTester.egg-info/top_level.txt

{flasktester-5.0 → flasktester-6.0}/FlaskTester.egg-info/requires.txt

@@ -7,6 +7,7 @@ pyright
 ruff
 coverage
 pymarkdownlnt!=0.9.5
+flake8
 types-flask
 types-requests
 FlaskSimpleAuth>=35.0

{flasktester-5.0 → flasktester-6.0}/FlaskTester.py

@@ -7,7 +7,8 @@ import os
 import io
 import re
 # Python >= 3.11: Self
-from typing import Any, Callable
+from typing import Any
+from collections.abc import Callable
 import importlib
 import logging
 import pytest  # for explicit fail calls, see _pytestFail
@@ -90,23 +91,26 @@ class Authenticator:
     _AUTH_SCHEMES.update(_TOKEN_SCHEMES)
     _AUTH_SCHEMES.update(_PASS_SCHEMES)
 
+    # should not be mutable
+    _AUTH_DEFAULT_SCHEMES = ["bearer", "basic", "param", "none"]
+
     # authenticator login/pass hook
     _AuthHook = Callable[[str, str|None], None]
 
     def __init__(self,
-             allow: list[str] = ["bearer", "basic", "param", "none"],
-             # parameter names for "basic" and "param"
-             user: str = "USER",
-             pwd: str = "PASS",
-             # parameter name for "fake"
-             login: str = "LOGIN",
-             # 4 token options
-             bearer: str = "Bearer",
-             header: str = "Auth",
-             cookie: str = "auth",
-             tparam: str = "AUTH",
-             ptype: str = "data",
-         ):
+            allow: list[str] = _AUTH_DEFAULT_SCHEMES,
+            # parameter names for "basic" and "param"
+            user: str = "USER",
+            pwd: str = "PASS",
+            # parameter name for "fake"
+            login: str = "LOGIN",
+            # 4 token options
+            bearer: str = "Bearer",
+            header: str = "Auth",
+            cookie: str = "auth",
+            tparam: str = "AUTH",
+            ptype: str = "data",
+        ):
 
         self._has_pass, self._has_token = False, False
         for auth in allow:
@@ -139,8 +143,7 @@ class Authenticator:
     def _set(self, key: str, val: str|None, store: dict[str, str]):
         """Set a key/value in a directory, with None for delete."""
         if val is None:
-            if key in store:
-                del store[key]
+            store.pop(key, None)
         else:
             assert isinstance(val, str)
             store[key] = val
@@ -315,6 +318,7 @@ class Client:
     AuthHook = Callable[[Any, str, str|None], None]  # type: ignore
 
     def __init__(self, auth: Authenticator, default_login: str|None = None):
+        self._calls = 0
         self._auth = auth
         self._cookies: dict[str, dict[str, str]] = {}  # login -> name -> value
         self._default_login = default_login
@@ -357,6 +361,8 @@ class Client:
         :param **kwargs: More request parameters (headers, data, json…).
         """
 
+        self._calls += 1
+
         if "login" in kwargs:
             login = kwargs["login"]
             del kwargs["login"]
@@ -387,7 +393,7 @@ class Client:
                 elif "model_dump" in val.__dir__() and callable(val.model_dump):
                     # probably pydantic
                     json_param[name] = val.model_dump()
-                else: # pydantic or standard dataclasses?
+                else:  # pydantic or standard dataclasses?
                     json_param[name] = dataclasses.asdict(val)
 
         # convert data parameters to simple strings
@@ -415,16 +421,14 @@ class Client:
         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
-                # FIXME what if the useful part is at the end?
-                _pytestFail(f"bad {status} result: {res.status_code} {res.text[:512]}...")
+        if status is not None and res.status_code != status:  # show error before aborting
+            # FIXME what if the useful part is at the end?
+            _pytestFail(f"bad {status} result: {res.status_code} {res.text[:512]}...")
 
         # check content
-        if content is not None:
-            if not re.search(content, res.text, re.DOTALL):
-                # FIXME what if the useful part is at the end?
-                _pytestFail(f"cannot find {content} in {res.text[:512]}...")
+        if content is not None and not re.search(content, res.text, re.DOTALL):
+            # FIXME what if the useful part is at the end?
+            _pytestFail(f"cannot find {content} in {res.text[:512]}...")
 
         return res
 
@@ -448,6 +452,12 @@ class Client:
         """HTTP DELETE request, see `Client.request`."""
         return self.request("DELETE", path, status=status, content=content, **kwargs)
 
+    def __str__(self):
+        return f"client calls: {self._calls}"
+
+    def __del__(self):
+        log.info(f"ending, {self}")
+
 
 class RequestClient(Client):
     """Request-based test provider.
@@ -526,6 +536,7 @@ class FlaskClient(Client):
 
         return self._client.open(method=method, path=path, **kwargs)
 
+
 def _ft_authenticator():
     """Fixture implementation, separated for testing purposes."""
 
@@ -559,6 +570,7 @@ def _ft_authenticator():
 
     return auth
 
+
 @pytest.fixture
 def ft_authenticator():
     """Pytest Fixture: ft_authenticator.
@@ -593,6 +605,7 @@ def ft_authenticator():
 
     yield _ft_authenticator()
 
+
 def _ft_client(authenticator):
     """Fixture implementation separated for testing."""
 
@@ -601,7 +614,7 @@ def _ft_client(authenticator):
 
     test_app = os.environ.get("FLASK_TESTER_APP", "app")
 
-    if test_app.startswith("http://") or test_app.startswith("https://"):
+    if test_app.startswith(("http://", "https://")):
         client = RequestClient(authenticator, test_app, default_login)
     else:
         # load app package
@@ -627,6 +640,7 @@ def _ft_client(authenticator):
 
     return client
 
+
 @pytest.fixture
 def ft_client(ft_authenticator):
     """Pytest Fixture: ft_client.

flasktester-6.0/MANIFEST.in

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

{flasktester-5.0 → flasktester-6.0}/PKG-INFO

@@ -1,16 +1,15 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: FlaskTester
-Version: 5.0
+Version: 6.0
 Summary: Pytest fixtures for Flask internal and external authenticated tests
 Author-email: Fabien Coelho <flask.tester@coelho.net>
-License: CC0
+License-Expression: CC0-1.0
 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
@@ -26,6 +25,7 @@ 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: flake8; extra == "dev"
 Requires-Dist: types-flask; extra == "dev"
 Requires-Dist: types-requests; extra == "dev"
 Requires-Dist: FlaskSimpleAuth>=35.0; extra == "dev"
@@ -41,6 +41,7 @@ Provides-Extra: pub
 Requires-Dist: build; extra == "pub"
 Requires-Dist: twine; extra == "pub"
 Requires-Dist: wheel; extra == "pub"
+Dynamic: license-file
 
 # FlaskTester - Pytest fixtures for Flask internal and external authenticated tests
 

{flasktester-5.0 → flasktester-6.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "FlaskTester"
-version = "5.0"
+version = "6.0"
 authors = [ { name = "Fabien Coelho", email = "flask.tester@coelho.net" } ]
 description = "Pytest fixtures for Flask internal and external authenticated tests"
 readme = "README.md"
-license = { text = "CC0" }
+license = "CC0-1.0"
 requires-python = ">=3.10"
 dependencies = [
   "requests",
@@ -17,7 +17,6 @@ dependencies = [
 classifiers = [
   "Development Status :: 5 - Production/Stable",
   "Intended Audience :: Developers",
-  "License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication",
   "Programming Language :: Python",
   "Environment :: Web Environment",
   "Framework :: Flask",
@@ -34,7 +33,7 @@ package = "https://pypi.org/project/FlaskTester/"
 # various dev tools
 dev = [
   # static checks…
-  "mypy", "pyright", "ruff", "coverage", "pymarkdownlnt!=0.9.5",
+  "mypy", "pyright", "ruff", "coverage", "pymarkdownlnt!=0.9.5", "flake8",
   # tests
   "types-flask", "types-requests", "FlaskSimpleAuth>=35.0", "bcrypt", "pydantic"
 ]
@@ -48,3 +47,7 @@ py-modules = [ "FlaskTester" ]
 [tool.black]
 line-length = 100
 target-version = ["py310"]
+
+[tool.ruff.lint]
+# ruff rules are what they are, but they are not always right
+ignore = ["BLE001", "B006", "I001", "SIM114", "RUF012", "PIE790"]

flasktester-5.0/MANIFEST.in

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

flasktester-5.0/tests/test_app.py

@@ -1,392 +0,0 @@
-import os
-import pytest
-import FlaskSimpleAuth as fsa
-import FlaskTester as ft
-from FlaskTester import ft_client, ft_authenticator
-import secret
-import http.server as htsv
-import threading
-import io
-import logging
-import model
-
-logging.basicConfig(level=logging.INFO)
-# logging.basicConfig(level=logging.DEBUG)
-log = logging.getLogger("test")
-
-# set authn for ft_authenticator
-os.environ.update(
-    FLASK_TESTER_TESTING="*",
-    FLASK_TESTER_ALLOW="bearer basic param none",
-    FLASK_TESTER_AUTH=",".join(f"{l}:{p}" for l, p in secret.PASSES.items()),
-)
-
-def test_sanity():
-    # must provide url or package of Flask application to test
-    assert "FLASK_TESTER_APP" in os.environ
-    # log.debug(f"TEST_SEED={os.environ.get('TEST_SEED')}")
-
-# example from README.md
-def authHook(api, user: str, pwd: str|None):
-    if pwd is not None:  # get token
-        try:
-            res = api.get("/login", login=user, auth="basic", status=200)
-            api.setToken(user, res.json["token"])
-        except ft.FlaskTesterError as e:  # pragma: no cover
-            log.warning(f"error: {e}")
-    else:  # cleanup
-        api.setToken(user, None)
-
-@pytest.fixture
-def app(ft_client):
-    # hook when adding login/passwords
-    ft_client.setHook(authHook)
-    # Calvin authentication
-    ft_client.setPass("calvin", secret.PASSES["calvin"])
-    ft_client.setCookie("hobbes", "lang", "fr")
-    # Hobbes authentication
-    ft_client.setPass("hobbes", secret.PASSES["hobbes"])
-    ft_client.setCookie("calvin", "lang", "en")
-    # return working client
-    yield ft_client
-    # cleanup
-    ft_client.setPass("calvin", None)
-    ft_client.setPass("hobbes", None)
-
-def test_app_admin(app):  # GET /admin
-    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
-
-def test_app_who_am_i(app):  # GET /who-am-i
-    app.get("/who-am-i", login=None, status=401)
-    for auth in ["bearer", "basic", "param"]:
-        res = app.get("/who-am-i", login="calvin", auth=auth, status=200)
-        assert res.json["lang"] == "en" and res.json["isadmin"]
-        res = app.get("/who-am-i", login="hobbes", auth=auth, status=200)
-        assert res.json["lang"] == "fr" and not res.json["isadmin"]
-
-@pytest.fixture
-def api(ft_client):
-    # set a default
-    ft_client._default_login = "calvin"
-    # bad password and token
-    ft_client.setPass("moe", None)
-    ft_client.setToken("moe", None)
-    ft_client.setPass("moe", "bad password")
-    ft_client.setToken("moe", "bad token")
-    # set language cookies
-    ft_client.setCookie("calvin", "lang", "en")
-    ft_client.setCookie("hobbes", "lang", "fr")
-    # get valid tokens using password authn on /login
-    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("/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("/login", login="susie", auth="param", status=201, json={})
-    assert res.json["user"] == "susie"
-    ft_client._auth.setToken("susie", res.json["token"])
-    ft_client.get("/login", login="calvin", auth="none", status=401)
-    # check that token auth and cookie is ok
-    res = ft_client.get("/who-am-i", login="calvin", status=200, auth="bearer")
-    assert res.json["user"] == "calvin" and res.json["lang"] == "en"
-    res = ft_client.get("/who-am-i", login="hobbes", status=200, auth="bearer")
-    assert res.json["user"] == "hobbes" and res.json["lang"] == "fr"
-    res = ft_client.get("/who-am-i", login="susie", status=200, auth="bearer")
-    assert res.json["user"] == "susie" and res.json["lang"] is None
-    # with defaults
-    res = ft_client.get("/who-am-i", auth="basic", status=200)
-    assert res.json["user"] == "calvin"
-    res = ft_client.get("/who-am-i", auth="param", status=200)
-    assert res.json["user"] == "calvin"
-    res = ft_client.get("/who-am-i", auth="bearer", status=200)
-    assert res.json["user"] == "calvin"
-    res = ft_client.get("/who-am-i", status=200)
-    assert res.json["user"] == "calvin"
-    # ready for testing routes
-    yield ft_client
-
-def test_admin(api):
-    # check authentication schemes
-    for auth in (None, "basic", "param", "bearer"):
-        api.get("/admin", status=200, login="calvin", auth=auth)
-        api.get("/admin", 200, login="susie", auth=auth)
-        api.get("/admin", 403, login="hobbes", auth=auth)
-        api.get("/admin", 401, login="moe", auth=auth)
-        api.get("/admin", 401, login=None, auth=auth)
-        # test status error
-        try:
-            api.get("/admin", status=599, login="calvin", auth=auth)
-            pytest.fail("assert on status must fail")  # pragma: no cover
-        except ft._AssertError as e:
-            assert "200" in str(e)
-        # test content error
-        try:
-            api.get("/admin", status=200, login="calvin", auth=auth, content="NOT THERE")
-            pytest.fail("assert on content must fail")  # pragma: no cover
-        except ft._AssertError as e:
-            assert "NOT THERE" in str(e)
-
-def test_errors(api):
-    # these schemes are not allowed
-    for scheme in ("header", "cookie", "fake", "tparam"):
-        try:
-            api.get("/login", login="calvin", auth=scheme)
-            pytest.fail("must raise an exception")  # pragma: no cover
-        except ft.AuthError as e:
-            assert "auth is not allowed" in str(e)
-    try:
-        api.get("/login", login="calvin", auth="foobla")
-        pytest.fail("must raise an exception")  # pragma: no cover
-    except ft.AuthError as e:
-        assert "unexpected auth" in str(e)
-
-def test_methods(api):
-    res = api.get("/who-am-i", login="susie", status=200, cookies={"lang": "it"})
-    assert res.json["lang"] == "it"
-    api.post("/who-am-i", login="hobbes", status=405)
-    api.put("/who-am-i", login="hobbes", status=405)
-    api.patch("/who-am-i", login="hobbes", status=405)
-    api.delete("/who-am-i", login="hobbes", status=405)
-
-def test_hello(api):
-    res = api.get("/hello", login="calvin", auth="none", status=200)
-    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["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["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["lang"] == "en" and res.json["hello"] == "Hi"
-    assert res.headers["FSA-User"] == "None (None)"
-
-def test_authenticator_token():
-    # all token carriers
-    auth = ft.Authenticator(allow=["bearer", "header", "tparam", "cookie"])
-    auth.setToken("calvin", "clv-token")
-    auth.setToken("susie", "ss-token")
-    auth.setToken("hobbes", "hbs-token")
-    auth.setToken("moe", "m-token")
-    auth.setCookie("calvin", "what", "clv-cookie")
-    kwargs, cookies = {}, {}
-    auth.setAuth("calvin", kwargs, cookies, auth="bearer")
-    assert kwargs["headers"]["Authorization"] == "Bearer clv-token"
-    assert cookies["what"] == "clv-cookie"
-    kwargs, cookies = {}, {}
-    auth.setAuth("susie", kwargs, cookies, auth="header")
-    assert kwargs["headers"]["Auth"] == "ss-token"
-    assert not cookies
-    kwargs, cookies = {"data": {}}, {}
-    auth.setAuth("hobbes", kwargs, cookies, auth="tparam")
-    assert kwargs["data"]["AUTH"] == "hbs-token"
-    assert not cookies
-    kwargs, cookies = {"json": {}}, {}
-    auth.setAuth("hobbes", kwargs, cookies, auth="tparam")
-    assert kwargs["json"]["AUTH"] == "hbs-token"
-    assert not cookies
-    kwargs, cookies = {}, {}
-    auth.setAuth("moe", kwargs, cookies, auth="cookie")
-    assert not kwargs
-    assert cookies["auth"] == "m-token"
-    # dad does not have a token
-    try:
-        kwargs, cookies = {}, {}
-        auth.setAuth("dad", kwargs, cookies)
-        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")
-        pytest.fail("must raise an error")  # pragma: no cover
-    except ft.AuthError:
-        assert True, "error raised"
-    # force to trigger later errors
-    auth._has_pass = True
-    auth.setPass("rosalyn", "rsln-pass")
-    try:
-        kwargs, cookies = {}, {}
-        auth.setAuth("rosalyn", kwargs, cookies)
-        pytest.fail("must raise an error")  # pragma: no cover
-    except ft.FlaskTesterError:
-        assert True, "error raised"
-
-def test_authenticator_password():
-    # all password carriers plus fake
-    auth = ft.Authenticator(allow=["basic", "param", "fake"])
-    auth.setPass("calvin", "clv-pass")
-    auth.setPass("hobbes", "hbs-pass")
-    auth.setPass("moe", "m-pass")
-    auth.setPass("rosalyn", "rsln-pass")
-    auth.setCookie("moe", "hello", "world!")
-    kwargs, cookies = {}, {}
-    auth.setAuth("calvin", kwargs, cookies, auth="basic")
-    assert kwargs["auth"] == ("calvin", "clv-pass")
-    assert not cookies
-    kwargs, cookies = {"data": {}}, {}
-    auth.setAuth("hobbes", kwargs, cookies, auth="param")
-    assert kwargs["data"]["USER"] == "hobbes" and kwargs["data"]["PASS"] == "hbs-pass"
-    assert not cookies
-    kwargs, cookies = {"json": {}}, {}
-    auth.setAuth("moe", kwargs, cookies, auth="param")
-    assert kwargs["json"]["USER"] == "moe" and kwargs["json"]["PASS"] == "m-pass"
-    assert cookies["hello"] == "world!"
-    kwargs, cookies = {"data": {}}, {}
-    auth.setAuth("rosalyn", kwargs, cookies, auth="fake")
-    assert kwargs["data"]["LOGIN"] == "rosalyn"
-    assert not cookies
-    kwargs, cookies = {"json": {}}, {}
-    auth.setAuth("hobbes", kwargs, cookies, auth="fake")
-    assert kwargs["json"]["LOGIN"] == "hobbes"
-    assert not cookies
-    # susie as a token, but no token carrier is allowed
-    try:
-        auth.setToken("susie", "ss-token")
-        pytest.fail("must raise an error")  # pragma: no cover
-    except ft.FlaskTesterError:
-        assert True, "error raised"
-    # force to trigger later error
-    auth._has_token = True
-    auth.setToken("susie", "ss-token")
-    try:
-        kwargs, cookies = {}, {}
-        auth.setAuth("susie", kwargs, cookies)
-        pytest.fail("must raise an error")  # pragma: no cover
-    except ft.FlaskTesterError:
-        assert True, "error raised"
-
-def test_request_flask_response():
-
-    class RequestResponse:
-        """Local class for testing RequestFlaskResponse."""
-
-        def __init__(self, is_json: bool):
-            self._is_json = is_json
-            self.status_code = 200
-            self.content = b"hello world!"
-            self.text = "hello world!"
-            self.headers = {"Server": "test/0.1"}
-            self.cookies = {}
-
-        def json(self):
-            if self._is_json:
-                return {"hello": "world!"}
-            else:
-                raise Exception("not json!")
-
-    jres = ft.RequestFlaskResponse(RequestResponse(True))
-    assert jres.is_json and jres.json is not None
-
-    xres = ft.RequestFlaskResponse(RequestResponse(False))
-    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", "/", {})
-        pytest.fail("must raise an error")  # pragma: no cover
-    except NotImplementedError:
-        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()
-    try:
-        client = ft.RequestClient(ft.Authenticator(), "http://localhost:8888")
-        client.get("/", 200)
-        client.request("GET", "/", 200)
-        hello = io.BytesIO(b"hello world")
-        client.post("/", 501, data={"hello": hello})
-        hello = io.BytesIO(b"hello world")
-        client.post("/", 501, data={"hello": (hello, "hello.txt", "text/plain")})
-        client.post("/", 501, data={"hello": "world!"})
-    finally:
-        httpd.shutdown()
-
-def test_client_fixture():
-    # ft_client coverage
-    auth = ft._ft_authenticator()
-    # check and save env
-    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, defaults to "app"
-    init = ft._ft_client(auth)
-    # url
-    os.environ["FLASK_TESTER_APP"] = "http://localhost:5000"
-    init = ft._ft_client(auth)
-    assert isinstance(init, ft.RequestClient)
-    del os.environ["FLASK_TESTER_APP"]
-    # 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 app:
-        os.environ["FLASK_TESTER_APP"] = app
-
-def test_classes(api):
-
-    def thing_eq(ta, tb):
-        ta = model.Thing1(**ta) if isinstance(ta, dict) else ta
-        tb = model.Thing1(**tb) if isinstance(tb, dict) else tb
-        return ta.tid == tb.tid and ta.name == tb.name and ta.owner == tb.owner
-
-    # Things
-    t0 = {"tid": 0, "name": "zero", "owner": "Rosalyn"}
-    t1 = model.Thing1(tid=1, name="one", owner="Susie")
-    t2 = model.Thing2(tid=2, name="two", owner="Calvin")
-    t3 = model.Thing3(tid=3, name="three", owner="Hobbes")
-
-    n = 0
-    # check all combinations
-    for path in ["/t0", "/t1", "/t2", "/t3"]:
-        for param in [t0, t1, t2, t3]:
-            for tclass in [dict, model.Thing1, model.Thing2, model.Thing3]:
-                for method in ["GET", "POST"]:
-                    for mode in ["data", "json"]:
-                        n +=1
-                        parameter = {mode: {"t": param}}
-                        res = api.request(method, path, 200, **parameter)
-                        assert res.is_json and isinstance(res.json, dict)
-                        assert thing_eq(tclass(**res.json), param)
-    assert n == 256
-
-    # simple types translation
-    assert api.get("/t0", 200, json={"t": None}).json is None
-    assert api.get("/t0", 200, data={"t": None}).json is None
-    assert api.get("/t0", 200, json={"t": True}).json == True
-    assert api.get("/t0", 200, json={"t": False}).json == False
-    # non working, bad JsonData conversion
-    api.get("/t0", 400, data={"t": True})
-    api.get("/t0", 400, data={"t": False})
-    assert api.get("/t0", 200, json={"t": 2345}).json == 2345
-    assert api.get("/t0", 200, data={"t": 5432}).json == 5432
-    assert api.get("/t0", 200, json={"t": 23.45}).json == 23.45
-    assert api.get("/t0", 200, data={"t": 54.32}).json == 54.32
-    assert api.get("/t0", 200, json={"t": "Susie"}).json == "Susie"
-    api.get("/t0", 400, data={"t": "Susie"})  # raw str is not JSON
-    assert api.get("/t0", 200, data={"t": "\"Susie\""}).json == "Susie"

flasktester-5.0/tests/test_app2.py

@@ -1,37 +0,0 @@
-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)
-
-def test_params(app):
-    res = app.get("/add", 200, data={"i": 39, "j": 3}, login=None)
-    assert res.is_json and res.json["sum"] == 42
-    res = app.get("/add", 200, json={"i": 35, "j": 7}, login=None)
-    assert res.is_json and res.json["sum"] == 42
-    # mixing data/json is okay for FlaskTester
-    res = app.get("/add", 200, data={"i": 30}, json={"j": 12}, login=None)
-    assert res.is_json and res.json["sum"] == 42