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

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/schema/user.py

@@ -9,6 +9,7 @@ from sqlmodel import Field, SQLModel
 
 class UserBase(SQLModel):
     username: str
+    active: bool
 
 
 class UserCreate(UserBase):
@@ -23,7 +24,7 @@ class UserCreateWithAudit(UserCreate):
 
 
 class UserCreateWithRoles(UserCreate):
-    role_ids: list[str] | None = None
+    role_names: list[str] | None = None
 
     def with_audit(self, created_by: str) -> "UserCreateWithRolesAndAudit":
         return UserCreateWithRolesAndAudit(**self.model_dump(), created_by=created_by)
@@ -33,18 +34,21 @@ class UserCreateWithRolesAndAudit(UserCreateWithRoles):
     created_by: str
 
     def get_user_create_with_audit(self) -> UserCreateWithAudit:
-        data = {key: val for key, val in self.model_dump().items() if key != "role_ids"}
+        data = {
+            key: val for key, val in self.model_dump().items() if key != "role_names"
+        }
         return UserCreateWithAudit(**data)
 
-    def get_role_ids(self) -> list[str]:
-        if self.role_ids is None:
+    def get_role_names(self) -> list[str]:
+        if self.role_names is None:
             return []
-        return self.role_ids
+        return self.role_names
 
 
 class UserUpdate(SQLModel):
     username: str | None = None
     password: str | None = None
+    active: bool | None = None
 
     def with_audit(self, updated_by: str) -> "UserUpdateWithAudit":
         return UserUpdateWithAudit(**self.model_dump(), updated_by=updated_by)
@@ -55,7 +59,7 @@ class UserUpdateWithAudit(UserUpdate):
 
 
 class UserUpdateWithRoles(UserUpdate):
-    role_ids: list[str] | None = None
+    role_names: list[str] | None = None
 
     def with_audit(self, updated_by: str) -> "UserUpdateWithRolesAndAudit":
         return UserUpdateWithRolesAndAudit(**self.model_dump(), updated_by=updated_by)
@@ -65,19 +69,32 @@ class UserUpdateWithRolesAndAudit(UserUpdateWithRoles):
     updated_by: str
 
     def get_user_update_with_audit(self) -> UserUpdateWithAudit:
-        data = {key: val for key, val in self.model_dump().items() if key != "role_ids"}
+        data = {
+            key: val for key, val in self.model_dump().items() if key != "role_names"
+        }
         return UserUpdateWithAudit(**data)
 
-    def get_role_ids(self) -> list[str]:
-        if self.role_ids is None:
+    def get_role_names(self) -> list[str]:
+        if self.role_names is None:
             return []
-        return self.role_ids
+        return self.role_names
 
 
 class UserResponse(UserBase):
     id: str
-    roles: list[Role]
-    permissions: list[Permission]
+    role_names: list[str]
+    permission_names: list[str]
+
+
+class AuthUserResponse(UserResponse):
+    is_super_user: bool
+    is_guest: bool
+
+    def has_permission(self, permission_name: str):
+        return self.is_super_user or permission_name in self.permission_names
+
+    def has_role(self, role_name: str):
+        return self.is_super_user or role_name in self.role_names
 
 
 class MultipleUserResponse(BaseModel):
@@ -85,7 +102,30 @@ class MultipleUserResponse(BaseModel):
     count: int
 
 
+class UserCredentials(SQLModel):
+    username: str
+    password: str
+
+
+class UserTokenData(SQLModel):
+    access_token: str
+    refresh_token: str
+    access_token_expired_at: datetime.datetime
+    refresh_token_expired_at: datetime.datetime
+
+
+class UserSessionResponse(SQLModel):
+    id: str
+    user_id: str
+    access_token: str
+    refresh_token: str
+    token_type: str
+    access_token_expired_at: datetime.datetime
+    refresh_token_expired_at: datetime.datetime
+
+
 class User(SQLModel, table=True):
+    __tablename__ = "users"
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
     created_at: datetime.datetime = Field(index=True)
     created_by: str = Field(index=True)
@@ -93,11 +133,23 @@ class User(SQLModel, table=True):
     updated_by: str | None = Field(index=True)
     username: str = Field(index=True, unique=True)
     password: str
+    active: bool = Field(index=True)
 
 
 class UserRole(SQLModel, table=True):
+    __tablename__ = "user_roles"
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
     user_id: str = Field(index=True)
     role_id: str = Field(index=True)
     created_at: datetime.datetime | None
     created_by: str | None
+
+
+class UserSession(SQLModel, table=True):
+    __tablename__ = "user_sessions"
+    id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
+    user_id: str = Field(index=True)
+    access_token: str = Field(index=True)
+    refresh_token: str = Field(index=True)
+    access_token_expired_at: datetime.datetime = Field(index=True)
+    refresh_token_expired_at: datetime.datetime = Field(index=True)

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")