zrb 1.0.0b9__py3-none-any.whl → 1.1.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/test/auth/permission/test_update_permission.py

@@ -0,0 +1,66 @@
+from fastapi.testclient import TestClient
+from my_app_name.main import app
+from my_app_name.test._util.access_token import get_admin_access_token
+
+
+def test_update_permission():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_permission_data = {
+        "name": "to-be-updated-permission",
+        "description": "to-be-updated-permission-description",
+    }
+    insert_response = client.post(
+        "/api/v1/permissions",
+        json=new_permission_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    id = insert_response.json().get("id")
+    # updating
+    updated_permission_data = {
+        "name": "updated-permission",
+        "description": "updated-permission-description",
+    }
+    response = client.put(
+        f"/api/v1/permissions/{id}",
+        json=updated_permission_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data.get("id") == id
+    assert response_data.get("name") == "updated-permission"
+    assert response_data.get("description") == "updated-permission-description"
+
+
+def test_update_permission_bulk():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_first_permission_data = {
+        "name": "to-be-updated-permission-bulk-1",
+        "description": "to-be-updated-permission-bulk-description-1",
+    }
+    insert_response = client.post(
+        "/api/v1/permissions/bulk",
+        json=[new_first_permission_data],
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    ids = [row["id"] for row in insert_response.json()]
+    # updating (we only test with one data)
+    updated_permission_data = {"description": "updated-permission-description"}
+    response = client.put(
+        f"/api/v1/permissions/bulk",
+        json={
+            "permission_ids": ids,
+            "data": updated_permission_data,
+        },
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert len(response_data) == 1
+    response_data[0].get("id") == ids[0]
+    response_data[0].get("name") == new_first_permission_data["name"]
+    response_data[0].get("description") == new_first_permission_data["description"]

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/test/auth/test_user_session.py

@@ -0,0 +1,195 @@
+import time
+from typing import Annotated
+
+from fastapi import Depends
+from fastapi.testclient import TestClient
+from my_app_name.config import (
+    APP_AUTH_ACCESS_TOKEN_COOKIE_NAME,
+    APP_AUTH_GUEST_USER,
+    APP_AUTH_GUEST_USER_PERMISSIONS,
+    APP_AUTH_REFRESH_TOKEN_COOKIE_NAME,
+    APP_AUTH_SUPER_USER,
+    APP_AUTH_SUPER_USER_PASSWORD,
+)
+from my_app_name.main import app
+from my_app_name.module.gateway.util.auth import get_current_user
+from my_app_name.schema.user import AuthUserResponse
+
+
+@app.get("/test/current-user", response_model=AuthUserResponse)
+async def serve_get_current_user(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+) -> AuthUserResponse:
+    return current_user
+
+
+def test_create_invalid_user_session():
+    client = TestClient(app, base_url="http://localhost")
+    response = client.post(
+        "/api/v1/user-sessions",
+        data={
+            "username": "nonExistingUserFromSevenKingdom",
+            "password": "nonExistingSecurity",
+        },
+    )
+    assert response.status_code == 401
+
+
+def test_get_guest_user():
+    client = TestClient(app, base_url="http://localhost")
+    # Fetch current user
+    response = client.get("/test/current-user")
+    assert response.status_code == 200
+    user_data = response.json()
+    assert user_data.get("username") == APP_AUTH_GUEST_USER
+    assert not user_data.get("is_super_user")
+    assert user_data.get("is_guest")
+    assert user_data.get("permission_names") == APP_AUTH_GUEST_USER_PERMISSIONS
+
+
+def test_create_admin_user_session():
+    client = TestClient(app, base_url="http://localhost")
+    # Create new admin user session and check the response
+    session_response = client.post(
+        "/api/v1/user-sessions",
+        data={
+            "username": APP_AUTH_SUPER_USER,
+            "password": APP_AUTH_SUPER_USER_PASSWORD,
+        },
+    )
+    assert session_response.status_code == 200
+    session_data = session_response.json()
+    assert session_data.get("user_id") == APP_AUTH_SUPER_USER
+    assert session_data.get("token_type") == "bearer"
+    assert "access_token" in session_data
+    assert "access_token_expired_at" in session_data
+    assert "refresh_token" in session_data
+    assert "refresh_token_expired_at" in session_data
+    assert session_response.cookies.get(
+        APP_AUTH_ACCESS_TOKEN_COOKIE_NAME
+    ) == session_data.get("access_token")
+    assert session_response.cookies.get(
+        APP_AUTH_REFRESH_TOKEN_COOKIE_NAME
+    ) == session_data.get("refresh_token")
+
+
+def test_get_admin_user_with_bearer():
+    client = TestClient(app, base_url="http://localhost")
+    session_response = client.post(
+        "/api/v1/user-sessions",
+        data={
+            "username": APP_AUTH_SUPER_USER,
+            "password": APP_AUTH_SUPER_USER_PASSWORD,
+        },
+    )
+    assert session_response.status_code == 200
+    access_token = session_response.json()["access_token"]
+    # Fetch current user with bearer token
+    response = client.get(
+        "/test/current-user", headers={"Authorization": f"Bearer {access_token}"}
+    )
+    assert response.status_code == 200
+    user_data = response.json()
+    assert user_data.get("username") == APP_AUTH_SUPER_USER
+    assert user_data.get("is_super_user")
+    assert not user_data.get("is_guest")
+
+
+def test_get_admin_user_with_cookie():
+    login_client = TestClient(app, base_url="http://localhost")
+    session_response = login_client.post(
+        "/api/v1/user-sessions",
+        data={
+            "username": APP_AUTH_SUPER_USER,
+            "password": APP_AUTH_SUPER_USER_PASSWORD,
+        },
+    )
+    assert session_response.status_code == 200
+    # Fetch current user with cookies
+    cookies = {
+        APP_AUTH_ACCESS_TOKEN_COOKIE_NAME: session_response.cookies.get(
+            APP_AUTH_ACCESS_TOKEN_COOKIE_NAME
+        )
+    }
+    # re-initiate client with cookies
+    client = TestClient(app, base_url="http://localhost", cookies=cookies)
+    response = client.get("/test/current-user")
+    assert response.status_code == 200
+    user_data = response.json()
+    assert user_data.get("username") == APP_AUTH_SUPER_USER
+    assert user_data.get("is_super_user")
+    assert not user_data.get("is_guest")
+
+
+def test_update_user_session():
+    login_client = TestClient(app, base_url="http://localhost")
+    old_session_response = login_client.post(
+        "/api/v1/user-sessions",
+        data={
+            "username": APP_AUTH_SUPER_USER,
+            "password": APP_AUTH_SUPER_USER_PASSWORD,
+        },
+    )
+    assert old_session_response.status_code == 200
+    old_session_data = old_session_response.json()
+    # re-initiate client with cookies and delete user session
+    client = TestClient(app, base_url="http://localhost")
+    time.sleep(1)
+    new_session_response = client.put(
+        "/api/v1/user-sessions",
+        params={"refresh_token": old_session_data.get("refresh_token")},
+    )
+    assert new_session_response.status_code == 200
+    new_session_data = new_session_response.json()
+    # Cookies and response should match
+    assert new_session_response.cookies.get(
+        APP_AUTH_ACCESS_TOKEN_COOKIE_NAME
+    ) == new_session_data.get("access_token")
+    assert new_session_response.cookies.get(
+        APP_AUTH_REFRESH_TOKEN_COOKIE_NAME
+    ) == new_session_data.get("refresh_token")
+    # New session should has longer TTL than old session
+    assert old_session_data.get("access_token") != new_session_data.get("access_token")
+    assert old_session_data.get("access_token_expired_at") < new_session_data.get(
+        "access_token_expired_at"
+    )
+    assert old_session_data.get("refresh_token") != new_session_data.get(
+        "refresh_token"
+    )
+    assert old_session_data.get("refresh_token_expired_at") < new_session_data.get(
+        "refresh_token_expired_at"
+    )
+
+
+def test_delete_user_session():
+    login_client = TestClient(app, base_url="http://localhost")
+    session_response = login_client.post(
+        "/api/v1/user-sessions",
+        data={
+            "username": APP_AUTH_SUPER_USER,
+            "password": APP_AUTH_SUPER_USER_PASSWORD,
+        },
+    )
+    assert session_response.status_code == 200
+    # Initiate cookies that should be deleted when user session is deleted.
+    cookies = {
+        APP_AUTH_ACCESS_TOKEN_COOKIE_NAME: session_response.cookies.get(
+            APP_AUTH_ACCESS_TOKEN_COOKIE_NAME
+        ),
+        APP_AUTH_REFRESH_TOKEN_COOKIE_NAME: session_response.cookies.get(
+            APP_AUTH_REFRESH_TOKEN_COOKIE_NAME
+        ),
+    }
+    # re-initiate client with cookies and delete user session
+    client = TestClient(app, base_url="http://localhost", cookies=cookies)
+    response = client.delete(
+        "/api/v1/user-sessions",
+        params={
+            "refresh_token": session_response.cookies.get(
+                APP_AUTH_REFRESH_TOKEN_COOKIE_NAME
+            ),
+        },
+    )
+    assert response.status_code == 200
+    assert response.cookies.get(APP_AUTH_ACCESS_TOKEN_COOKIE_NAME, None) is None
+    assert response.cookies.get(APP_AUTH_REFRESH_TOKEN_COOKIE_NAME, None) is None

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/test/test_health_and_readiness.py

@@ -0,0 +1,28 @@
+from fastapi.testclient import TestClient
+from my_app_name.main import app
+
+
+def test_get_health():
+    client = TestClient(app, base_url="http://localhost")
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json() == {"message": "ok"}
+
+
+def test_head_health():
+    client = TestClient(app, base_url="http://localhost")
+    response = client.head("/health")
+    assert response.status_code == 200
+
+
+def test_get_readiness():
+    client = TestClient(app, base_url="http://localhost")
+    response = client.get("/readiness")
+    assert response.status_code == 200
+    assert response.json() == {"message": "ok"}
+
+
+def test_head_readiness():
+    client = TestClient(app, base_url="http://localhost")
+    response = client.head("/readiness")
+    assert response.status_code == 200

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/test/test_homepage.py

@@ -0,0 +1,15 @@
+import os
+
+from fastapi.testclient import TestClient
+from my_app_name.main import app
+from my_app_name.module.gateway.util.view import render_content
+
+
+def test_homepage():
+    client = TestClient(app, base_url="http://localhost")
+    response = client.get("/")
+    assert response.status_code == 200
+    view_path = os.path.join(
+        os.path.dirname(os.path.dirname(__file__)), "module", "gateway", "view"
+    )
+    assert response.text == render_content("homepage.html").body.decode("utf-8")

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/test/test_not_found_error.py

@@ -0,0 +1,16 @@
+import os
+
+from fastapi.testclient import TestClient
+from my_app_name.main import app
+from my_app_name.module.gateway.util.view import render_error
+
+
+def test_not_found_error():
+    client = TestClient(app, base_url="http://localhost")
+    response = client.get(
+        "/holly-grail/not-found/philosopher-stone/not-found/hope/inexist"
+    )
+    assert response.status_code == 404
+    assert response.text == render_error(
+        error_message="Not found", status_code=404
+    ).body.decode("utf-8")

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/test.sh

@@ -0,0 +1,7 @@
+pytest -vv \
+ --cov=my_app_name \
+ --cov-config=.coveragerc \
+ --cov-report=html \
+ --cov-report=term \
+ --cov-report=term-missing \
+ --ignore=_zrb

zrb/runner/web_route/refresh_token_api_route.py

@@ -30,7 +30,7 @@ def serve_refresh_token_api(app: "FastAPI", web_config: WebConfig) -> None:
         # If we still don't have a refresh token, raise an exception
         if not refresh_token:
             return JSONResponse(
-                content={"detail": "Refresh token not provided"}, status_code=400
+                content={"detail": "Refresh token not provided"}, status_code=401
             )
         # Get token
         new_token = regenerate_tokens(web_config, refresh_token)

zrb/runner/web_route/static/refresh-token.template.js

@@ -1,6 +1,10 @@
 function refreshAuthToken(){
     const refreshUrl = "/api/v1/refresh-token";
+    let shouldRefresh = true;
     async function refresh() {
+        if (!shouldRefresh) {
+            return;
+        }
         try {
             const response = await fetch(refreshUrl, {
                 method: "POST",
@@ -9,6 +13,11 @@ function refreshAuthToken(){
             });
 
             if (!response.ok) {
+                if (response.status === 401 || response.status === 403) {
+                    console.warn("Skipping token refresh, authentication required.");
+                    shouldRefresh = false;
+                    return;
+                }
                 throw new Error(`HTTP error! Status: ${response.status}`);
             }
             console.log("Token refreshed successfully");

zrb/runner/web_route/static/static_route.py

@@ -30,7 +30,7 @@ def serve_static_resources(app: "FastAPI", web_config: WebConfig) -> None:
     async def refresh_token_js():
         return PlainTextResponse(
             content=_get_refresh_token_js(
-                60 * web_config.refresh_token_expire_minutes / 3
+                60 * web_config.access_token_expire_minutes / 3
             ),
             media_type="application/javascript",
         )

zrb/task/base_task.py

@@ -295,16 +295,16 @@ class BaseTask(AnyTask):
     async def exec_root_tasks(self, session: AnySession):
         session.set_main_task(self)
         session.state_logger.write(session.as_state_log())
-        log_state = asyncio.create_task(self._log_session_state(session))
-        root_tasks = [
-            task
-            for task in session.get_root_tasks(self)
-            if session.is_allowed_to_run(task)
-        ]
-        root_task_coros = [
-            run_async(root_task.exec_chain(session)) for root_task in root_tasks
-        ]
         try:
+            log_state = asyncio.create_task(self._log_session_state(session))
+            root_tasks = [
+                task
+                for task in session.get_root_tasks(self)
+                if session.is_allowed_to_run(task)
+            ]
+            root_task_coros = [
+                run_async(root_task.exec_chain(session)) for root_task in root_tasks
+            ]
             await asyncio.gather(*root_task_coros)
             await session.wait_deferred()
             session.terminate()
@@ -312,7 +312,7 @@ class BaseTask(AnyTask):
             return session.final_result
         except IndexError:
             return None
-        except asyncio.CancelledError:
+        except (asyncio.CancelledError, KeyboardInterrupt):
             ctx = self.get_ctx(session)
             ctx.log_info("Session terminated")
         finally:

zrb/util/codemod/modification_mode.py

@@ -0,0 +1,3 @@
+PREPEND = 0
+APPEND = 1
+REPLACE = 2

zrb/util/codemod/modify_class.py

@@ -0,0 +1,58 @@
+import libcst as cst
+
+from zrb.util.codemod.modification_mode import APPEND, PREPEND, REPLACE
+
+
+def replace_class_code(original_code: str, class_name: str, new_code: str) -> str:
+    return _modify_code(original_code, class_name, new_code, REPLACE)
+
+
+def prepend_code_to_class(original_code: str, class_name: str, new_code: str) -> str:
+    return _modify_code(original_code, class_name, new_code, PREPEND)
+
+
+def append_code_to_class(original_code: str, class_name: str, new_code: str) -> str:
+    return _modify_code(original_code, class_name, new_code, APPEND)
+
+
+def _modify_code(original_code: str, class_name: str, new_code: str, mode: int) -> str:
+    # Parse the original code into a module
+    module = cst.parse_module(original_code)
+    # Initialize transformer with the class name and method code
+    transformer = _ClassCodeModifier(class_name, new_code, mode)
+    # Apply the transformation
+    modified_module = module.visit(transformer)
+    # Check if the class was found
+    if not transformer.class_found:
+        raise ValueError(f"Class {class_name} not found in the provided code.")
+    # Return the modified code
+    return modified_module.code
+
+
+class _ClassCodeModifier(cst.CSTTransformer):
+    def __init__(self, class_name: str, new_code: str, mode: int):
+        self.class_name = class_name
+        self.new_code = cst.parse_module(new_code).body
+        self.class_found = False
+        self.mode = mode
+
+    def leave_ClassDef(
+        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
+    ) -> cst.ClassDef:
+        # Check if this is the target class
+        if original_node.name.value == self.class_name:
+            self.class_found = True
+            if self.mode == REPLACE:
+                new_body = updated_node.body.with_changes(body=tuple(self.new_code))
+                return updated_node.with_changes(body=new_body)
+            if self.mode == PREPEND:
+                new_body = updated_node.body.with_changes(
+                    body=tuple(self.new_code) + updated_node.body.body
+                )
+                return updated_node.with_changes(body=new_body)
+            if self.mode == APPEND:
+                new_body = updated_node.body.with_changes(
+                    body=updated_node.body.body + tuple(self.new_code)
+                )
+                return updated_node.with_changes(body=new_body)
+        return updated_node

zrb/util/codemod/modify_class_parent.py

@@ -0,0 +1,68 @@
+import libcst as cst
+
+from zrb.util.codemod.modification_mode import APPEND, PREPEND, REPLACE
+
+
+def replace_parent_class(
+    original_code: str, class_name: str, parent_class_name: str
+) -> str:
+    return _modify_parent_class(original_code, class_name, parent_class_name, REPLACE)
+
+
+def append_parent_class(
+    original_code: str, class_name: str, parent_class_name: str
+) -> str:
+    return _modify_parent_class(original_code, class_name, parent_class_name, APPEND)
+
+
+def prepend_parent_class(
+    original_code: str, class_name: str, parent_class_name: str
+) -> str:
+    return _modify_parent_class(original_code, class_name, parent_class_name, PREPEND)
+
+
+def _modify_parent_class(
+    original_code: str, class_name: str, parent_class_name: str, mode: int
+) -> str:
+    # Parse the original code into a module
+    module = cst.parse_module(original_code)
+    # Initialize transformer with the class name and parent class name
+    transformer = _ParentClassAdder(class_name, parent_class_name, mode)
+    # Apply the transformation
+    modified_module = module.visit(transformer)
+    # Check if the class was found
+    if not transformer.class_found:
+        raise ValueError(f"Class {class_name} not found in the provided code.")
+    # Return the modified code
+    return modified_module.code
+
+
+class _ParentClassAdder(cst.CSTTransformer):
+    def __init__(self, class_name: str, parent_class_name: str, mode: int):
+        self.class_name = class_name
+        self.parent_class_name = parent_class_name
+        self.class_found = False
+        self.mode = mode
+
+    def leave_ClassDef(
+        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
+    ) -> cst.ClassDef:
+        # Check if this is the target class
+        if original_node.name.value == self.class_name:
+            self.class_found = True
+            if self.mode == REPLACE:
+                new_bases = (cst.Arg(value=cst.Name(self.parent_class_name)),)
+                return updated_node.with_changes(bases=new_bases)
+            if self.mode == PREPEND:
+                new_bases = (
+                    cst.Arg(value=cst.Name(self.parent_class_name)),
+                    *updated_node.bases,
+                )
+                return updated_node.with_changes(bases=new_bases)
+            if self.mode == APPEND:
+                new_bases = (
+                    *updated_node.bases,
+                    cst.Arg(value=cst.Name(self.parent_class_name)),
+                )
+                return updated_node.with_changes(bases=new_bases)
+        return updated_node

zrb/util/codemod/modify_class_property.py

@@ -0,0 +1,128 @@
+import libcst as cst
+
+from zrb.util.codemod.modification_mode import APPEND, PREPEND
+
+
+def append_property_to_class(
+    original_code: str,
+    class_name: str,
+    property_name: str,
+    annotation: str,
+    default_value: str,
+) -> str:
+    return _modify_class_property(
+        original_code, class_name, property_name, annotation, default_value, APPEND
+    )
+
+
+def prepend_property_to_class(
+    original_code: str,
+    class_name: str,
+    property_name: str,
+    annotation: str,
+    default_value: str,
+) -> str:
+    return _modify_class_property(
+        original_code, class_name, property_name, annotation, default_value, PREPEND
+    )
+
+
+def _modify_class_property(
+    original_code: str,
+    class_name: str,
+    property_name: str,
+    annotation: str,
+    default_value: str,
+    mode: int,
+) -> str:
+    # Parse the original code into a module
+    module = cst.parse_module(original_code)
+    # Initialize transformer with the class name, property name, annotation, and default value
+    transformer = _ClassPropertyModifier(
+        class_name, property_name, annotation, default_value, mode
+    )
+    # Apply the transformation
+    modified_module = module.visit(transformer)
+    # Check if the class was found
+    if not transformer.class_found:
+        raise ValueError(f"Class {class_name} not found in the provided code.")
+    # Return the modified code
+    return modified_module.code
+
+
+class _ClassPropertyModifier(cst.CSTTransformer):
+    def __init__(
+        self,
+        class_name: str,
+        property_name: str,
+        annotation: str,
+        default_value: str,
+        mode: int,
+    ):
+        self.class_name = class_name
+        self.property_name = property_name
+        self.annotation = cst.Annotation(cst.parse_expression(annotation))
+        self.default_value = cst.parse_expression(default_value)
+        self.class_found = False
+        self.mode = mode
+
+    def leave_ClassDef(
+        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
+    ) -> cst.ClassDef:
+        # Check if this is the target class
+        if original_node.name.value == self.class_name:
+            self.class_found = True
+            # Create the annotated property with a default value
+            new_property = cst.SimpleStatementLine(
+                body=[
+                    cst.AnnAssign(
+                        target=cst.Name(self.property_name),
+                        annotation=self.annotation,
+                        value=self.default_value,
+                    )
+                ]
+            )
+            if self.mode == PREPEND:
+                new_body = cst.IndentedBlock(
+                    body=(new_property,) + updated_node.body.body
+                )
+                return updated_node.with_changes(body=new_body)
+            if self.mode == APPEND:
+                # Identify properties and methods
+                properties = []
+                methods = []
+                for stmt in updated_node.body.body:
+                    if isinstance(stmt, cst.SimpleStatementLine) and isinstance(
+                        stmt.body[0], (cst.AnnAssign, cst.Assign)
+                    ):
+                        properties.append(stmt)
+                    elif isinstance(stmt, cst.FunctionDef):
+                        methods.append(stmt)
+                if properties:
+                    # Class has properties
+                    last_property_index = updated_node.body.body.index(properties[-1])
+                    new_body = cst.IndentedBlock(
+                        body=(
+                            updated_node.body.body[: last_property_index + 1]
+                            + (new_property,)
+                            + updated_node.body.body[last_property_index + 1 :]
+                        )
+                    )
+                    return updated_node.with_changes(body=new_body)
+                if methods:
+                    # Class doesn't have properties but has methods
+                    first_method_index = updated_node.body.body.index(methods[0])
+                    new_body = cst.IndentedBlock(
+                        body=(
+                            updated_node.body.body[:first_method_index]
+                            + (new_property,)
+                            + updated_node.body.body[first_method_index:]
+                        )
+                    )
+                    return updated_node.with_changes(body=new_body)
+                # Class is empty, add add the bottom
+                new_body = cst.IndentedBlock(
+                    body=updated_node.body.body + (new_property,)
+                )
+                return updated_node.with_changes(body=new_body)
+        return updated_node