fastlifeweb 0.16.4__py3-none-any.whl → 0.18.0__py3-none-any.whl

fastlife/testing/testclient.py

@@ -1,9 +1,6 @@
 """Testing your application."""
 
-import re
-import time
-from collections.abc import Iterator, Mapping, MutableMapping, Sequence
-from http.cookiejar import Cookie
+from collections.abc import Mapping, MutableMapping
 from typing import Any, Literal
 from urllib.parse import urlencode
 
@@ -16,336 +13,14 @@ from starlette.types import ASGIApp
 from fastlife.config.settings import Settings
 from fastlife.middlewares.session.serializer import AbsractSessionSerializer
 from fastlife.shared_utils.resolver import resolve
+from fastlife.testing.dom import Element
+from fastlife.testing.form import WebForm
+from fastlife.testing.session import Session
 
 CookieTypes = httpx._types.CookieTypes  # type: ignore
 Cookies = httpx._models.Cookies  # type: ignore
 
 
-class Element:
-    """Access to a dom element."""
-
-    def __init__(self, client: "WebTestClient", tag: bs4.Tag):
-        self._client = client
-        self._tag = tag
-
-    def click(self) -> "WebResponse":
-        """Simulate a client to a a link. No javascript exectuted here."""
-        return self._client.get(self._tag.attrs["href"])
-
-    @property
-    def node_name(self) -> str:
-        """Get the node name of the dom element."""
-        return self._tag.name
-
-    @property
-    def attrs(self) -> dict[str, str]:
-        """Attributes of the element."""
-        return self._tag.attrs
-
-    @property
-    def text(self) -> str:
-        """
-        Return the text of the element, with text of childs element.
-
-        Note that the text is stripped for convenience but inner text may contains
-        many spaces not manipulated here.
-        """
-        return self._tag.text.strip()
-
-    @property
-    def h1(self) -> "Element":
-        """
-        Return the h1 child element.
-
-        Should be used on the html body element directly.
-        """
-        nodes = self.by_node_name("h1")
-        assert len(nodes) == 1, f"Should have 1 <h1>, got {len(nodes)} in {self}"
-        return nodes[0]
-
-    @property
-    def h2(self) -> Sequence["Element"]:
-        """
-        Return the h2 elements.
-        """
-        return self.by_node_name("h2")
-
-    @property
-    def form(self) -> "Element | None":
-        """Get the form element of the web page."""
-        return Element(self._client, self._tag.form) if self._tag.form else None
-
-    @property
-    def hx_target(self) -> str | None:
-        """
-        Return the hx-target of the element.
-
-        It may be set on a parent. It also resolve special case "this" and return the id
-        of the element.
-        """
-        el: bs4.Tag | None = self._tag
-        while el:
-            if "hx-target" in el.attrs:
-                ret = el.attrs["hx-target"]
-                if ret == "this":
-                    ret = el.attrs["id"]
-                return ret
-            el = el.parent
-        return None
-
-    def by_text(self, text: str, *, node_name: str | None = None) -> "Element | None":
-        """Find the first element that match the text."""
-        nodes = self.iter_all_by_text(text, node_name=node_name)
-        return next(nodes, None)
-
-    def iter_all_by_text(
-        self, text: str, *, node_name: str | None = None
-    ) -> "Iterator[Element]":
-        """Return an iterator of all elements that match the text."""
-        nodes = self._tag.find_all(string=re.compile(rf"\s*{text}\s*"))
-        for node in nodes:
-            if isinstance(node, bs4.NavigableString):
-                node = node.parent
-
-            if node_name:
-                while node is not None:
-                    if node.name == node_name:
-                        yield Element(self._client, node)
-                    node = node.parent
-            elif node:
-                yield Element(self._client, node)
-        return None
-
-    def get_all_by_text(
-        self, text: str, *, node_name: str | None = None
-    ) -> "Sequence[Element]":
-        """Return the list of all elements that match the text."""
-        nodes = self.iter_all_by_text(text, node_name=node_name)
-        return list(nodes)
-
-    def by_label_text(self, text: str) -> "Element | None":
-        """Return the element which is the target of the label having the given text."""
-        label = self.by_text(text, node_name="label")
-        assert label is not None
-        assert label.attrs.get("for") is not None
-        resp = self._tag.find(id=label.attrs["for"])
-        assert not isinstance(resp, bs4.NavigableString)
-        return Element(self._client, resp) if resp else None
-
-    def by_node_name(
-        self, node_name: str, *, attrs: dict[str, str] | None = None
-    ) -> list["Element"]:
-        """
-        Return the list of elements with the given node_name.
-
-        An optional set of attributes may given and must match if passed.
-        """
-        return [
-            Element(self._client, e) for e in self._tag.find_all(node_name, attrs or {})
-        ]
-
-    def __repr__(self) -> str:
-        return f"<{self.node_name}>"
-
-    def __str__(self) -> str:
-        return str(self._tag)
-
-
-class WebForm:
-    """
-    Handle html form.
-
-    Form are filled out and submit with methods and try to avoid invalid
-    usage, such as selecting an option that don't exists is not possible here.
-    Again, no javascript is executed here, but htmx attribute `hx-post` and `hx-target`
-    are read while submiting to simulate it.
-    """
-
-    def __init__(self, client: "WebTestClient", origin: str, form: Element):
-        self._client = client
-        self._form = form
-        self._origin = origin
-        self._formfields: dict[str, Element] = {}
-        self._formdata: MultiDict[str] = MultiDict()
-        inputs = self._form.by_node_name("input")
-        for input in inputs:
-            self._formfields[input.attrs["name"]] = input
-            if input.attrs.get("type") == "checkbox" and "checked" not in input.attrs:
-                continue
-            self._formdata.add(input.attrs["name"], input.attrs.get("value", ""))
-
-        selects = self._form.by_node_name("select")
-        for select in selects:
-            fieldname = select.attrs["name"]
-            self._formfields[fieldname] = select
-            options = select.by_node_name("option")
-            if "multiple" in select.attrs:
-                for option in options:
-                    if "selected" in option.attrs:
-                        self._formdata.add(
-                            fieldname, option.attrs.get("value", option.text)
-                        )
-            else:
-                if options:
-                    self._formdata[fieldname] = options[0].attrs.get(
-                        "value", options[0].text
-                    )
-                    for option in options:
-                        if "selected" in option.attrs:
-                            self._formdata[fieldname] = option.attrs.get(
-                                "value", option.text
-                            )
-                            break
-
-        # field textearea...
-
-    def set(self, fieldname: str, value: str) -> Any:
-        """
-        Set a value to an input field.
-
-        It works for checkbox and radio as well.
-        Checkbox may contains many values.
-        Options of select can't be set with this method, the select method must
-        be used instead.
-        """
-        if fieldname not in self._formfields:
-            raise ValueError(f'"{fieldname}" does not exists')
-        if self._formfields[fieldname].node_name == "select":
-            raise ValueError(f'"{fieldname}" is a <select>, use select() instead')
-
-        if self._formfields[fieldname].attrs.get("type") == "checkbox":
-            self._formdata.add(fieldname, value)
-            return
-
-        if self._formfields[fieldname].attrs.get("type") == "radio":
-            radio = self._form.by_node_name(
-                "input", attrs={"type": "radio", "value": value}
-            )
-            if not radio:
-                raise ValueError(
-                    f'radio "{fieldname}" does not contains {value} option'
-                )
-
-        self._formdata[fieldname] = value
-
-    def unset(self, fieldname: str, value: str) -> Any:
-        """Unset an element. Only works with checkbox."""
-        if fieldname not in self._formfields:
-            raise ValueError(f'"{fieldname}" does not exists')
-        if self._formfields[fieldname].node_name != "input":
-            raise ValueError(f'"{fieldname}" is not a checkbox')
-        if self._formfields[fieldname].attrs.get("type") != "checkbox":
-            raise ValueError(f'"{fieldname}" is not a checkbox')
-        values = self._formdata.popall(fieldname)
-        if value not in values:
-            raise ValueError(f'"{value}" not in "{fieldname}"')
-        for val in values:
-            if val != value:
-                self._formdata[fieldname] = val
-
-    def select(self, fieldname: str, value: str) -> Any:
-        """
-        Select an option, if multiple, value is added, otherwise, value is replaced.
-        """
-        if fieldname not in self._formfields:
-            raise ValueError(f'"{fieldname}" does not exists')
-        field = self._formfields[fieldname]
-        if field.node_name != "select":
-            raise ValueError(f"{fieldname} is a {field!r}, " "use set() instead")
-
-        for option in field.by_node_name("option"):
-            if option.text == value.strip():
-                if "multiple" in field.attrs:
-                    self._formdata.add(fieldname, value)
-                else:
-                    self._formdata[fieldname] = option.attrs.get("value", option.text)
-                break
-        else:
-            raise ValueError(f'No option {value} in <select name="{fieldname}">')
-
-    def unselect(self, fieldname: str, value: str) -> Any:
-        """
-        Unselect an option if multiple, otherwise an exception is raised.
-        """
-        if fieldname not in self._formfields:
-            raise ValueError(f'"{fieldname}" does not exists')
-        field = self._formfields[fieldname]
-
-        if field.node_name != "select":
-            raise ValueError(
-                f"{fieldname} is a {self._formfields[fieldname]!r}, "
-                "use unset() for checkbox instead"
-            )
-        if "multiple" not in field.attrs:
-            raise ValueError("only <select multiple> support unselect")
-
-        for option in self._formfields[fieldname].by_node_name("option"):
-            if option.text == value.strip():
-                values = self._formdata.popall(fieldname)
-                if value not in values:
-                    raise ValueError(f'"{value}" not selected in "{fieldname}"')
-                for val in values:
-                    if val != value:
-                        self._formdata[fieldname] = val
-                break
-        else:
-            raise ValueError(f'No option {value} in <select name="{fieldname}">')
-
-    def button(self, text: str, position: int = 0) -> "WebForm":
-        """
-        Simmulate a click on a button using the text of the button,
-
-        and eventually a position. The button return the form and the submit()
-        should be called directly.
-
-        This is used in order to inject the value of the button in the form, usually
-        done while many actions are available on a form.
-
-        ::
-
-            form.button("Go").submit()
-
-        """
-        buttons = self._form.get_all_by_text(text, node_name="button")
-        if position >= len(buttons):
-            pos = ""
-            if position > 0:
-                pos = f" at position {position}"
-            raise ValueError(f'Button "{text}" not found{pos}')
-        button = buttons[position]
-        if "name" in button.attrs:
-            self._formdata[button.attrs["name"]] = button.attrs.get("value", "")
-        return self
-
-    def submit(self, follow_redirects: bool = True) -> "WebResponse":
-        """
-        Submit the form as it has been previously filled out.
-        """
-        headers: dict[str, str] = {}
-        target = (
-            self._form.attrs.get("hx-post")
-            or self._form.attrs.get("post")
-            or self._origin
-        )
-        if "hx-post" in self._form.attrs:
-            if hx_target := self._form.hx_target:
-                headers["HX-Target"] = hx_target
-
-        return self._client.post(
-            target,
-            data=self._formdata,
-            headers=headers,
-            follow_redirects=follow_redirects,
-        )
-
-    def __contains__(self, key: str) -> bool:
-        """Test if a field exists in the form."""
-        return key in self._formdata
-
-    def __repr__(self) -> str:
-        return repr(self._formdata)
-
-
 class WebResponse:
     """Represent an http response made by the WebTestClient browser."""
 
@@ -419,64 +94,6 @@ class WebResponse:
         return self.html.by_node_name(node_name, attrs=attrs)
 
 
-class Session(dict[str, Any]):
-    """Manipulate the session of the WebTestClient browser."""
-
-    def __init__(self, client: "WebTestClient"):
-        self.client = client
-        self.srlz = client.session_serializer
-        self.settings = self.client.settings
-        data: Mapping[str, Any]
-        cookie_name = self.settings.session_cookie_name
-        self.has_session = cookie_name in self.client.cookies
-        if self.has_session:
-            data, error = self.srlz.deserialize(
-                self.client.cookies[cookie_name].encode("utf-8")
-            )
-            if error:
-                self.has_session = False
-        else:
-            data = {}
-        super().__init__(data)
-
-    def __setitem__(self, __key: Any, __value: Any) -> None:
-        """Initialize a value in the session of the client in order to test."""
-        super().__setitem__(__key, __value)
-        settings = self.settings
-        data = self.serialize()
-        self.client.cookies.jar.set_cookie(
-            Cookie(
-                version=0,
-                name=settings.session_cookie_name,
-                value=data,
-                port=None,
-                port_specified=False,
-                domain=f".{settings.session_cookie_domain}",
-                domain_specified=True,
-                domain_initial_dot=True,
-                path="/",
-                path_specified=True,
-                secure=False,
-                expires=int(time.time() + settings.session_duration.total_seconds()),
-                discard=False,
-                comment=None,
-                comment_url=None,
-                rest={"HttpOnly": None, "SameSite": "lax"},  # type: ignore
-                rfc2109=False,
-            )
-        )
-        # this does not work
-        # self.client.cookies.set(
-        #     settings.session_cookie_name,
-        #     data,
-        #     settings.session_cookie_domain,
-        #     settings.session_cookie_path,
-        # )
-
-    def serialize(self) -> str:
-        return self.srlz.serialize(self).decode("utf-8")
-
-
 class WebTestClient:
     """The fake browser used for testing purpose."""
 

{fastlifeweb-0.16.4.dist-info → fastlifeweb-0.18.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastlifeweb
-Version: 0.16.4
+Version: 0.18.0
 Summary: High-level web framework
 Home-page: https://github.com/mardiros/fastlife
 License: BSD-derived
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Provides-Extra: doc
 Provides-Extra: testing
 Requires-Dist: babel (>=2.16.0,<3.0.0)
 Requires-Dist: beautifulsoup4 (>=4.12.2,<5.0.0) ; extra == "testing"
@@ -28,6 +29,7 @@ Requires-Dist: multidict (>=6.0.5,<7.0.0)
 Requires-Dist: pydantic (>=2.5.3,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.0.3,<3.0.0)
 Requires-Dist: python-multipart (>=0.0.9,<0.0.10)
+Requires-Dist: sphinx (>=7.0.1,<8.0.0) ; extra == "doc"
 Requires-Dist: venusian (>=3.0.0,<4.0.0)
 Project-URL: Repository, https://github.com/mardiros/fastlife
 Description-Content-Type: text/markdown
@@ -37,24 +39,24 @@ Description-Content-Type: text/markdown
 [![Documentation](https://github.com/mardiros/fastlife/actions/workflows/gh-pages.yml/badge.svg)](https://mardiros.github.io/fastlife/)
 [![Continuous Integration](https://github.com/mardiros/fastlife/actions/workflows/main.yml/badge.svg)](https://github.com/mardiros/fastlife/actions/workflows/main.yml)
 [![Coverage Report](https://codecov.io/gh/mardiros/fastlife/graph/badge.svg?token=DTpi73d7mf)](https://codecov.io/gh/mardiros/fastlife)
-
+[![Maintainability](https://api.codeclimate.com/v1/badges/94d107797b15b5e8843e/maintainability)](https://codeclimate.com/github/mardiros/fastlife/maintainability)
 
 > ⚠️ **Under Heavy Development**
 > Please note that this project is still in active development. Features and APIs may change frequently.
 > Even the name is not definitive.
 
-An opinionated Python web framework (based on FastAPI).
+An opinionated Python web framework (based on {term}`FastAPI`).
 
 ## Purpose
 
 Fastlife helps at building Web Application with session, security, html test client,
 and html form generated from pydantic schema using customizable widget.
 
-Templates are made using [JinjaX](https://jinjax.scaletti.dev/) and an extensible [set of
+Templates are made using {term}`JinjaX` and an extensible [set of
 component](https://mardiros.github.io/fastlife/components/index.html) is available
 in order to build pages.
 
-Those components are currently stylized by [tailwindcss](https://tailwindcss.com/),
+Those components are currently stylized by {term}`Tailwind CSS`,
 using [pytailwindcss](https://github.com/timonweb/pytailwindcss).
 
 Moreover, you can also write API, in an opinionated way to enforce documentation
@@ -63,7 +65,7 @@ consistency.
 
 ## First class configuration.
 
-Fastlife is adding a "Configurator", like Pyramid to get a better scallable codebase.
+Fastlife is adding a "Configurator", like {term}`Pyramid` to get a better scallable codebase.
 
 The configurator in fastlife organizes configuration settings hierarchically,
 enabling easy management and overriding at different levels.