zrb 1.0.0b9__py3-none-any.whl → 1.0.0b10__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/test/_util/access_token.py

@@ -0,0 +1,19 @@
+import time
+
+from fastapi.testclient import TestClient
+from my_app_name.config import APP_AUTH_SUPER_USER, APP_AUTH_SUPER_USER_PASSWORD
+from my_app_name.main import app
+
+
+def get_admin_access_token():
+    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,
+        },
+    )
+    session_data = session_response.json()
+    return session_data.get("access_token")

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

@@ -0,0 +1,59 @@
+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_create_permission():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_permission_data = {
+        "name": "new-permission",
+        "description": "new-permission-description",
+    }
+    response = client.post(
+        "/api/v1/permissions",
+        json=new_permission_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data.get("id") is not None
+    assert response_data.get("id") != ""
+    assert response_data.get("name") == "new-permission"
+    assert response_data.get("description") == "new-permission-description"
+
+
+def test_create_permission_bulk():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_first_permission_data = {
+        "name": "new-permission-bulk-1",
+        "description": "new-permission-bulk-description-1",
+    }
+    new_second_permission_data = {
+        "name": "new-permission-bulk-2",
+        "description": "new-permission-bulk-description-2",
+    }
+    new_permission_data = [new_first_permission_data, new_second_permission_data]
+    response = client.post(
+        "/api/v1/permissions/bulk",
+        json=new_permission_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert len(response_data) == 2
+    # Id should not be empty
+    assert response_data[0] is not None
+    assert response_data[0] != ""
+    assert response_data[1] is not None
+    assert response_data[1] != ""
+    # Data should match
+    assert new_first_permission_data["name"] in [row["name"] for row in response_data]
+    assert new_second_permission_data["name"] in [row["name"] for row in response_data]
+    assert new_first_permission_data["description"] in [
+        row["description"] for row in response_data
+    ]
+    assert new_second_permission_data["description"] in [
+        row["description"] for row in response_data
+    ]

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

@@ -0,0 +1,68 @@
+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_delete_permission():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_permission_data = {
+        "name": "to-be-deleted-permission",
+        "description": "to-be-deleted-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")
+    # deleting
+    response = client.delete(
+        f"/api/v1/permissions/{id}", 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") == "to-be-deleted-permission"
+    assert response_data.get("description") == "to-be-deleted-permission-description"
+
+
+def test_delete_permission_bulk():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_first_permission_data = {
+        "name": "to-be-deleted-permission-bulk-1",
+        "description": "to-be-deleted-permission-bulk-description-1",
+    }
+    new_second_permission_data = {
+        "name": "to-be-deleted-permission-bulk-2",
+        "description": "to-be-deleted-permission-bulk-description-2",
+    }
+    new_permission_data = [new_first_permission_data, new_second_permission_data]
+    insert_response = client.post(
+        "/api/v1/permissions/bulk",
+        json=new_permission_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    ids = [row["id"] for row in insert_response.json()]
+    # deleting (use client.request since client.delete doesn't support json param)
+    response = client.request(
+        "DELETE",
+        f"/api/v1/permissions/bulk",
+        json=ids,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    # Data should match
+    assert len([row["id"] for row in response_data if row["id"] in ids]) == 2
+    assert new_first_permission_data["name"] in [row["name"] for row in response_data]
+    assert new_second_permission_data["name"] in [row["name"] for row in response_data]
+    assert new_first_permission_data["description"] in [
+        row["description"] for row in response_data
+    ]
+    assert new_second_permission_data["description"] in [
+        row["description"] for row in response_data
+    ]

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

@@ -0,0 +1,71 @@
+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_read_permission_by_id():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_permission_data = {
+        "name": "to-be-read-permission",
+        "description": "to-be-read-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")
+    # fetching
+    response = client.get(
+        f"/api/v1/permissions/{id}", 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") == "to-be-read-permission"
+    assert response_data.get("description") == "to-be-read-permission-description"
+
+
+def test_read_permission_bulk():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_first_permission_data = {
+        "name": "to-be-read-permission-bulk-1",
+        "description": "to-be-read-permission-bulk-description-1",
+    }
+    new_second_permission_data = {
+        "name": "to-be-read-permission-bulk-2",
+        "description": "to-be-read-permission-bulk-description-2",
+    }
+    new_permission_data = [new_first_permission_data, new_second_permission_data]
+    insert_response = client.post(
+        "/api/v1/permissions/bulk",
+        json=new_permission_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    ids = [row["id"] for row in insert_response.json()]
+    # fetching
+    response = client.get(
+        f"/api/v1/permissions",
+        params={
+            "filter": "name:like:to-be-read-permission-bulk-%",
+        },
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data_count = response.json()["count"]
+    assert response_data_count == 2
+    response_data = response.json()["data"]
+    # Data should match
+    assert len([row["id"] for row in response_data if row["id"] in ids]) == 2
+    assert new_first_permission_data["name"] in [row["name"] for row in response_data]
+    assert new_second_permission_data["name"] in [row["name"] for row in response_data]
+    assert new_first_permission_data["description"] in [
+        row["description"] for row in response_data
+    ]
+    assert new_second_permission_data["description"] in [
+        row["description"] for row in response_data
+    ]

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,17 @@
+import os
+
+from fastapi.testclient import TestClient
+from my_app_name.main import app
+from my_app_name.module.gateway.util.view import render
+
+
+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(
+        os.path.join(view_path, "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/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