fastlifeweb 0.2.1__tar.gz → 0.2.2__tar.gz

{fastlifeweb-0.2.1 → fastlifeweb-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastlifeweb
-Version: 0.2.1
+Version: 0.2.2
 Summary: High-level web framework
 License: BSD-derived
 Author: Guillaume Gauvrit

{fastlifeweb-0.2.1 → fastlifeweb-0.2.2}/pyproject.toml

@@ -13,7 +13,7 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: Internet :: WWW/HTTP",
 ]
-version = "0.2.1"
+version = "0.2.2"
 
 [tool.poetry.dependencies]
 python = "^3.11"

{fastlifeweb-0.2.1 → fastlifeweb-0.2.2}/src/fastlife/configurator/settings.py

@@ -19,6 +19,7 @@ class Settings(BaseSettings):
 
     session_secret_key: str = Field(default="")
     session_cookie_name: str = Field(default="flsess")
+    session_cookie_domain: str = Field(default="")
     session_cookie_path: str = Field(default="/")
     session_duration: timedelta = Field(default=timedelta(days=14))
     session_cookie_same_site: Literal["lax", "strict", "none"] = Field(default="lax")

{fastlifeweb-0.2.1 → fastlifeweb-0.2.2}/src/fastlife/session/__init__.py

@@ -17,6 +17,6 @@ def includeme(config: Configurator) -> None:
             cookie_path=settings.session_cookie_path,
             cookie_same_site=settings.session_cookie_same_site,
             cookie_secure=settings.session_cookie_secure,
-            cookie_domain=settings.domain_name,
+            cookie_domain=settings.session_cookie_domain,
             serializer=session_serializer,
         )

{fastlifeweb-0.2.1 → fastlifeweb-0.2.2}/src/fastlife/session/middleware.py

@@ -41,16 +41,18 @@ class SessionMiddleware(AbstractMiddleware):
             return
 
         connection = HTTPConnection(scope)
-        reset_session = False
-
-        if self.cookie_name in connection.cookies:
+        existing_session = self.cookie_name in connection.cookies
+        if existing_session:
             data = connection.cookies[self.cookie_name].encode("utf-8")
-            scope["session"], reset_session = self.serializer.deserialize(data)
+            scope["session"], broken_session = self.serializer.deserialize(data)
+            if broken_session:
+                existing_session = False
         else:
             scope["session"] = {}
 
         async def send_wrapper(message: Message) -> None:
             if message["type"] == "http.response.start":
+                headers = None
                 if scope["session"]:
                     # We have session data to persist.
                     data = self.serializer.serialize(scope["session"]).decode("utf-8")
@@ -60,7 +62,7 @@ class SessionMiddleware(AbstractMiddleware):
                         f"Max-Age={self.max_age}; {self.security_flags}"
                     )
                     headers.append("set-cookie", header_value)
-                elif reset_session:
+                elif existing_session:
                     # The session has been cleared.
                     headers = MutableHeaders(scope=message)
                     expires = "expires=Thu, 01 Jan 1970 00:00:00 GMT; "

{fastlifeweb-0.2.1 → fastlifeweb-0.2.2}/src/fastlife/session/serializer.py

@@ -34,6 +34,11 @@ class SignedSessionSerializer(AbsractSessionSerializer):
     def deserialize(self, data: bytes) -> Tuple[Mapping[str, Any], bool]:
         try:
             data = self.signer.unsign(data, max_age=self.max_age)
+            # We can't deserialize something wrong since the serialize
+            # is signing the content.
+            # If the signature key is compromise and we have invalid payload,
+            # raising exceptions here is fine, it's dangerous afterall.
+            session = json.loads(b64decode(data))
         except itsdangerous.BadSignature:
             return {}, True
-        return json.loads(b64decode(data)), False
+        return session, False

{fastlifeweb-0.2.1 → fastlifeweb-0.2.2}/src/fastlife/testing/testclient.py

@@ -1,4 +1,5 @@
 import re
+import time
 from collections.abc import MutableMapping
 from typing import Any, Literal, Mapping
 from urllib.parse import urlencode
@@ -13,13 +14,60 @@ from fastlife.session.serializer import AbsractSessionSerializer
 from fastlife.shared_utils.resolver import resolve
 
 
+class Element:
+    def __init__(self, client: "WebTestClient", tag: bs4.Tag):
+        self._client = client
+        self._tag = tag
+
+    def click(self) -> "WebResponse":
+        return self._client.get(self._tag.attrs["href"])
+
+    @property
+    def attrs(self) -> dict[str, str]:
+        return self._tag.attrs
+
+    @property
+    def form(self) -> "Element | None":
+        return Element(self._client, self._tag.form) if self._tag.form else None
+
+    def by_text(self, text: str, *, node_name: str | None = None) -> "Element | None":
+        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:
+                        return Element(self._client, node)
+                    node = node.parent
+            elif node:
+                return Element(self._client, node)
+        return None
+
+    def by_label_text(self, text: str) -> "Element | None":
+        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 [
+            Element(self._client, e) for e in self._tag.find_all(node_name, attrs or {})
+        ]
+
+
 class WebForm:
-    def __init__(self, client: "WebTestClient", origin: str, form: bs4.Tag):
+    def __init__(self, client: "WebTestClient", origin: str, form: Element):
         self._client = client
         self._form = form
         self._origin = origin
         self._formdata: dict[str, str] = {}
-        inputs = self._form.find_all("input")
+        inputs = self._form.by_node_name("input")
         for input in inputs:
             if input.attrs.get("type") == "checkbox" and "checked" not in input.attrs:
                 continue
@@ -32,7 +80,7 @@ class WebForm:
         self._formdata[fieldname] = value
 
     def button(self, text: str) -> "WebForm":
-        assert self._form.find("button", string=re.compile(f".*{text}.*")) is not None
+        assert self._form.by_text(text, node_name="button") is not None
         return self
 
     def submit(self, follow_redirects: bool = True) -> "WebResponse":
@@ -45,6 +93,9 @@ class WebForm:
             target, data=self._formdata, follow_redirects=follow_redirects
         )
 
+    def __contains__(self, key: str) -> bool:
+        return key in self._formdata
+
 
 class WebResponse:
     def __init__(self, client: "WebTestClient", origin: str, response: httpx.Response):
@@ -75,39 +126,16 @@ class WebResponse:
         return self._response.text
 
     @property
-    def html(self) -> bs4.Tag:
+    def html(self) -> Element:
         if self._html is None:
             self._html = bs4.BeautifulSoup(self._response.text, "html.parser")
-        return self._html
+        return Element(self._client, self._html)
 
     @property
-    def html_body(self) -> bs4.Tag:
-        body = self.html.find("body")
-        assert body is not None
-        assert isinstance(body, bs4.Tag)
-        return body
-
-    def by_text(self, text: str, *, node_name: str | None = None) -> bs4.Tag | None:
-        nodes = self.html.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:
-                        return node
-                    node = node.parent
-
-        return None
-
-    def by_label_text(self, text: str) -> bs4.Tag | None:
-        label = self.by_text(text, node_name="label")
-        assert label is not None
-        assert label.attrs.get("for") is not None
-        resp = self.html.find(id=label.attrs["for"])
-        assert not isinstance(resp, bs4.NavigableString)
-        return resp
+    def html_body(self) -> Element:
+        body = self.html.by_node_name("body")
+        assert len(body) == 1
+        return body[0]
 
     @property
     def form(self) -> WebForm:
@@ -117,10 +145,16 @@ class WebResponse:
             self._form = WebForm(self._client, self._origin, form)
         return self._form
 
+    def by_text(self, text: str, *, node_name: str | None = None) -> Element | None:
+        return self.html.by_text(text, node_name=node_name)
+
+    def by_label_text(self, text: str) -> Element | None:
+        return self.html.by_label_text(text)
+
     def by_node_name(
         self, node_name: str, *, attrs: dict[str, str] | None = None
-    ) -> list[bs4.Tag]:
-        return self.html.find_all(node_name, attrs or {})
+    ) -> list[Element]:
+        return self.html.by_node_name(node_name, attrs=attrs)
 
 
 CookieTypes = httpx._types.CookieTypes  # type: ignore
@@ -141,28 +175,51 @@ class Session(dict[str, Any]):
         assert settings is not None
         self.settings = settings
         data: Mapping[str, Any]
-        if settings.session_cookie_name in self.client.cookies:
-            data, exists = self.srlz.deserialize(
+        self.has_session = settings.session_cookie_name in self.client.cookies
+        if self.has_session:
+            data, error = self.srlz.deserialize(
                 self.client.cookies[settings.session_cookie_name].encode("utf-8")
             )
+            if error:
+                self.has_session = False
         else:
-            data, exists = {}, False
-        self.new_session = not exists
+            data = {}
         super().__init__(data)
 
     def __setitem__(self, __key: Any, __value: Any) -> None:
         super().__setitem__(__key, __value)
         settings = self.settings
         data = self.serialize()
-        if self.new_session:
-            self.client.cookies.set(
-                settings.session_cookie_name,
-                data,
-                settings.domain_name,
-                settings.session_cookie_path,
+        from http.cookiejar import Cookie
+
+        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,
             )
-        else:
-            self.client.cookies[settings.session_cookie_name] = data
+        )
+        # 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")
@@ -177,7 +234,12 @@ class WebTestClient:
         cookies: CookieTypes | None = None,
     ) -> None:
         self.app = app
-        self.testclient = TestClient(app, cookies=cookies or {})
+        if settings is None:
+            settings = Settings()
+            settings.domain_name = settings.domain_name or "testserver.local"
+        self.testclient = TestClient(
+            app, base_url=f"http://{settings.domain_name}", cookies=cookies or {}
+        )
         self.settings = settings
         self.session_serializer: AbsractSessionSerializer | None = None
         if settings:
@@ -212,7 +274,7 @@ class WebTestClient:
             url=url,
             headers=headers,
             content=content,
-            follow_redirects=False,  # don't follow for cookie processing
+            follow_redirects=False,
         )
         resp = WebResponse(
             self,