zrb 0.23.4__py3-none-any.whl → 0.24.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/log.py

@@ -1,6 +1,6 @@
 import logging
 
-from config import app_enable_otel, app_logging_level, app_otel_exporter_otlp_endpoint
+from config import APP_ENABLE_OTEL, APP_LOGGING_LEVEL, APP_OTEL_EXPORTER_OTLP_ENDPOINT
 from opentelemetry._logs import set_logger_provider
 from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
 from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
@@ -10,14 +10,14 @@ from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 # Create logger
 ##############################################################################
 logger = logging.getLogger("src")
-logger.setLevel(app_logging_level)
+logger.setLevel(APP_LOGGING_LEVEL)
 
 ##############################################################################
 # Formatter log handler
 ##############################################################################
 
 stream_handler = logging.StreamHandler()
-stream_handler.setLevel(app_logging_level)
+stream_handler.setLevel(APP_LOGGING_LEVEL)
 # create formatter
 formatter = logging.Formatter("%(levelname)s:\t%(message)s")
 # set stream handler's formatter
@@ -29,17 +29,17 @@ logger.addHandler(stream_handler)
 # Open telemetry log handler
 ##############################################################################
 
-if app_enable_otel:
+if APP_ENABLE_OTEL:
     # create logger providers
     otlp_logger_provider = LoggerProvider()
     # set the providers
     set_logger_provider(otlp_logger_provider)
-    otlp_log_exporter = OTLPLogExporter(endpoint=app_otel_exporter_otlp_endpoint)
+    otlp_log_exporter = OTLPLogExporter(endpoint=APP_OTEL_EXPORTER_OTLP_ENDPOINT)
     # add the batch processors to the trace provider
     otlp_logger_provider.add_log_record_processor(
         BatchLogRecordProcessor(otlp_log_exporter)
     )
     otlp_log_handler = LoggingHandler(
-        level=app_logging_level, logger_provider=otlp_logger_provider
+        level=APP_LOGGING_LEVEL, logger_provider=otlp_logger_provider
     )
     logger.addHandler(otlp_log_handler)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/messagebus.py

@@ -14,31 +14,31 @@ from component.messagebus import (
     RMQPublisher,
 )
 from config import (
-    app_broker_type,
-    app_kafka_bootstrap_servers,
-    app_kafka_sasl_mechanism,
-    app_kafka_sasl_pass,
-    app_kafka_sasl_user,
-    app_kafka_security_protocol,
-    app_rmq_connection_string,
-    zrb_app_name,
+    APP_BROKER_TYPE,
+    APP_KAFKA_BOOTSTRAP_SERVERS,
+    APP_KAFKA_SASL_MECHANISM,
+    APP_KAFKA_SASL_PASS,
+    APP_KAFKA_SASL_USER,
+    APP_KAFKA_SECURITY_PROTOCOL,
+    APP_NAME,
+    APP_RMQ_CONNECTION_STRING,
 )
 from integration.log import logger
 
 
 def init_admin(default_admin: Admin) -> Admin:
-    if app_broker_type == "rabbitmq":
+    if APP_BROKER_TYPE == "rabbitmq":
         return RMQAdmin(
-            logger=logger, connection_string=app_rmq_connection_string, configs={}
+            logger=logger, connection_string=APP_RMQ_CONNECTION_STRING, configs={}
         )
-    if app_broker_type == "kafka":
+    if APP_BROKER_TYPE == "kafka":
         return KafkaAdmin(
             logger=logger,
-            bootstrap_servers=app_kafka_bootstrap_servers,
-            security_protocol=app_kafka_security_protocol,
-            sasl_mechanism=app_kafka_sasl_mechanism,
-            sasl_plain_username=app_kafka_sasl_user,
-            sasl_plain_password=app_kafka_sasl_pass,
+            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
+            security_protocol=APP_KAFKA_SECURITY_PROTOCOL,
+            sasl_mechanism=APP_KAFKA_SASL_MECHANISM,
+            sasl_plain_username=APP_KAFKA_SASL_USER,
+            sasl_plain_password=APP_KAFKA_SASL_PASS,
             configs={},
         )
     return default_admin
@@ -47,21 +47,21 @@ def init_admin(default_admin: Admin) -> Admin:
 def init_publisher(
     serializer: MessageSerializer, admin: Admin, default_publisher: Publisher
 ) -> Publisher:
-    if app_broker_type == "rabbitmq":
+    if APP_BROKER_TYPE == "rabbitmq":
         return RMQPublisher(
             logger=logger,
-            connection_string=app_rmq_connection_string,
+            connection_string=APP_RMQ_CONNECTION_STRING,
             serializer=serializer,
             rmq_admin=admin,
         )
-    if app_broker_type == "kafka":
+    if APP_BROKER_TYPE == "kafka":
         return KafkaPublisher(
             logger=logger,
-            bootstrap_servers=app_kafka_bootstrap_servers,
-            security_protocol=app_kafka_security_protocol,
-            sasl_mechanism=app_kafka_sasl_mechanism,
-            sasl_plain_username=app_kafka_sasl_user,
-            sasl_plain_password=app_kafka_sasl_pass,
+            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
+            security_protocol=APP_KAFKA_SECURITY_PROTOCOL,
+            sasl_mechanism=APP_KAFKA_SASL_MECHANISM,
+            sasl_plain_username=APP_KAFKA_SASL_USER,
+            sasl_plain_password=APP_KAFKA_SASL_PASS,
             serializer=serializer,
             kafka_admin=admin,
         )
@@ -71,22 +71,22 @@ def init_publisher(
 def init_consumer(
     serializer: MessageSerializer, admin: Admin, default_consumer: Consumer
 ) -> Consumer:
-    if app_broker_type == "rabbitmq":
+    if APP_BROKER_TYPE == "rabbitmq":
         return RMQConsumer(
             logger=logger,
-            connection_string=app_rmq_connection_string,
+            connection_string=APP_RMQ_CONNECTION_STRING,
             serializer=serializer,
             rmq_admin=admin,
         )
-    if app_broker_type == "kafka":
+    if APP_BROKER_TYPE == "kafka":
         return KafkaConsumer(
             logger=logger,
-            bootstrap_servers=app_kafka_bootstrap_servers,
-            security_protocol=app_kafka_security_protocol,
-            sasl_mechanism=app_kafka_sasl_mechanism,
-            sasl_plain_username=app_kafka_sasl_user,
-            sasl_plain_password=app_kafka_sasl_pass,
-            group_id=zrb_app_name,
+            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
+            security_protocol=APP_KAFKA_SECURITY_PROTOCOL,
+            sasl_mechanism=APP_KAFKA_SASL_MECHANISM,
+            sasl_plain_username=APP_KAFKA_SASL_USER,
+            sasl_plain_password=APP_KAFKA_SASL_PASS,
+            group_id=APP_NAME,
             serializer=serializer,
             kafka_admin=admin,
         )

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/rpc.py

@@ -1,10 +1,10 @@
 from component.messagebus import KafkaConsumer, RMQConsumer
 from component.rpc import Caller, MessagebusCaller, MessagebusServer, Server
 from config import (
-    app_broker_type,
-    app_kafka_bootstrap_servers,
-    app_rmq_connection_string,
-    zrb_app_name,
+    APP_BROKER_TYPE,
+    APP_KAFKA_BOOTSTRAP_SERVERS,
+    APP_NAME,
+    APP_RMQ_CONNECTION_STRING,
 )
 from integration.log import logger
 from integration.messagebus import (
@@ -18,20 +18,20 @@ from ulid import ULID
 
 
 def create_consumer():
-    if app_broker_type == "rabbitmq":
+    if APP_BROKER_TYPE == "rabbitmq":
         return RMQConsumer(
             logger=logger,
-            connection_string=app_rmq_connection_string,
+            connection_string=APP_RMQ_CONNECTION_STRING,
             serializer=message_serializer,
             rmq_admin=admin,
             identifier="rmq-rpc-reply-consumer",
         )
-    if app_broker_type == "kafka":
+    if APP_BROKER_TYPE == "kafka":
         random_uuid = str(ULID())
-        group_id = f"{zrb_app_name}-reply-{random_uuid}"
+        group_id = f"{APP_NAME}-reply-{random_uuid}"
         return KafkaConsumer(
             logger=logger,
-            bootstrap_servers=app_kafka_bootstrap_servers,
+            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
             group_id=group_id,
             serializer=message_serializer,
             kafka_admin=admin,

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/integration/access_token_scheme.py

@@ -1,4 +1,4 @@
-from config import app_auth_access_token_cookie_key
+from config import APP_AUTH_ACCESS_TOKEN_COOKIE_KEY
 from module.auth.component import (
     AccessTokenScheme,
     create_oauth2_bearer_access_token_scheme,
@@ -11,6 +11,6 @@ access_token_scheme: AccessTokenScheme = (
         guest_user=guest_user,
         access_token_util=access_token_util,
         token_url="/api/v1/auth/login-oauth",
-        token_cookie_key=app_auth_access_token_cookie_key,
+        token_cookie_key=APP_AUTH_ACCESS_TOKEN_COOKIE_KEY,
     )
 )

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/integration/access_token_util.py

@@ -1,18 +1,18 @@
 from config import (
-    app_auth_access_token_type,
-    app_auth_jwt_token_algorithm,
-    app_auth_jwt_token_secret_key,
+    APP_AUTH_ACCESS_TOKEN_TYPE,
+    APP_AUTH_JWT_TOKEN_ALGORITHM,
+    APP_AUTH_JWT_TOKEN_SECRET_KEY,
 )
 from module.auth.component import AccessTokenUtil, JWTAccessTokenUtil
 
 
 def init_token_util() -> AccessTokenUtil:
-    if app_auth_access_token_type.lower() == "jwt":
+    if APP_AUTH_ACCESS_TOKEN_TYPE.lower() == "jwt":
         return JWTAccessTokenUtil(
-            secret_key=app_auth_jwt_token_secret_key,
-            algorithm=app_auth_jwt_token_algorithm,
+            secret_key=APP_AUTH_JWT_TOKEN_SECRET_KEY,
+            algorithm=APP_AUTH_JWT_TOKEN_ALGORITHM,
         )
-    raise ValueError(f"Invalid auth token type: {app_auth_access_token_type}")
+    raise ValueError(f"Invalid auth token type: {APP_AUTH_ACCESS_TOKEN_TYPE}")
 
 
 access_token_util = init_token_util()

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/integration/model/user_model.py

@@ -1,7 +1,7 @@
 from config import (
-    app_auth_access_token_expire_seconds,
-    app_auth_admin_active,
-    app_auth_refresh_token_expire_seconds,
+    APP_AUTH_ACCESS_TOKEN_EXPIRE_SECONDS,
+    APP_AUTH_ADMIN_ACTIVE,
+    APP_AUTH_REFRESH_TOKEN_EXPIRE_SECONDS,
 )
 from integration.messagebus import publisher
 from module.auth.entity.user.model import UserModel
@@ -15,10 +15,10 @@ user_model: UserModel = UserModel(
     publisher=publisher,
     permission_model=permission_model,
     access_token_util=access_token_util,
-    access_token_expire_seconds=app_auth_access_token_expire_seconds,
+    access_token_expire_seconds=APP_AUTH_ACCESS_TOKEN_EXPIRE_SECONDS,
     refresh_token_util=refresh_token_util,
-    refresh_token_expire_seconds=app_auth_refresh_token_expire_seconds,
+    refresh_token_expire_seconds=APP_AUTH_REFRESH_TOKEN_EXPIRE_SECONDS,
     guest_user=guest_user,
-    admin_user=admin_user if app_auth_admin_active else None,
+    admin_user=admin_user if APP_AUTH_ADMIN_ACTIVE else None,
     admin_user_password=admin_user_password,
 )

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/integration/refresh_token_util.py

@@ -1,18 +1,18 @@
 from config import (
-    app_auth_jwt_token_algorithm,
-    app_auth_jwt_token_secret_key,
-    app_auth_refresh_token_type,
+    APP_AUTH_JWT_TOKEN_ALGORITHM,
+    APP_AUTH_JWT_TOKEN_SECRET_KEY,
+    APP_AUTH_REFRESH_TOKEN_TYPE,
 )
 from module.auth.component import JWTRefreshTokenUtil, RefreshTokenUtil
 
 
 def init_token_util() -> RefreshTokenUtil:
-    if app_auth_refresh_token_type.lower() == "jwt":
+    if APP_AUTH_REFRESH_TOKEN_TYPE.lower() == "jwt":
         return JWTRefreshTokenUtil(
-            secret_key=app_auth_jwt_token_secret_key,
-            algorithm=app_auth_jwt_token_algorithm,
+            secret_key=APP_AUTH_JWT_TOKEN_SECRET_KEY,
+            algorithm=APP_AUTH_JWT_TOKEN_ALGORITHM,
         )
-    raise ValueError(f"Invalid auth token type: {app_auth_refresh_token_type}")
+    raise ValueError(f"Invalid auth token type: {APP_AUTH_REFRESH_TOKEN_TYPE}")
 
 
 refresh_token_util = init_token_util()

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/integration/user.py

@@ -1,33 +1,33 @@
 from config import (
-    app_auth_admin_email,
-    app_auth_admin_password,
-    app_auth_admin_phone,
-    app_auth_admin_user_id,
-    app_auth_admin_username,
-    app_auth_guest_email,
-    app_auth_guest_phone,
-    app_auth_guest_user_id,
-    app_auth_guest_username,
+    APP_AUTH_ADMIN_EMAIL,
+    APP_AUTH_ADMIN_PASSWORD,
+    APP_AUTH_ADMIN_PHONE,
+    APP_AUTH_ADMIN_USER_ID,
+    APP_AUTH_ADMIN_USERNAME,
+    APP_AUTH_GUEST_EMAIL,
+    APP_AUTH_GUEST_PHONE,
+    APP_AUTH_GUEST_USER_ID,
+    APP_AUTH_GUEST_USERNAME,
 )
 from module.auth.schema.user import User
 
-admin_user_password = app_auth_admin_password
+admin_user_password = APP_AUTH_ADMIN_PASSWORD
 
 admin_user = User(
-    id=app_auth_admin_user_id,
-    username=app_auth_admin_username,
-    email=app_auth_admin_email,
-    phone=app_auth_admin_phone,
+    id=APP_AUTH_ADMIN_USER_ID,
+    username=APP_AUTH_ADMIN_USERNAME,
+    email=APP_AUTH_ADMIN_EMAIL,
+    phone=APP_AUTH_ADMIN_PHONE,
     groups=[],
     permissions=[],
     description="System administrator",
 )
 
 guest_user = User(
-    id=app_auth_guest_user_id,
-    username=app_auth_guest_username,
-    email=app_auth_guest_email,
-    phone=app_auth_guest_phone,
+    id=APP_AUTH_GUEST_USER_ID,
+    username=APP_AUTH_GUEST_USERNAME,
+    email=APP_AUTH_GUEST_EMAIL,
+    phone=APP_AUTH_GUEST_PHONE,
     groups=[],
     permissions=[],
     description="Visitor",

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/migrate.py

@@ -1,4 +1,4 @@
-from config import app_enable_auth_module
+from config import APP_ENABLE_AUTH_MODULE
 from helper.migration import migrate
 from integration.db_connection import engine
 from integration.log import logger
@@ -7,7 +7,7 @@ from module.auth.register_permission import register_permission
 
 
 async def migrate_auth():
-    if not app_enable_auth_module:
+    if not APP_ENABLE_AUTH_MODULE:
         logger.info('🥪 Skip DB migration for "auth"')
         return
     logger.info('🥪 Perform DB migration for "auth"')

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/register_module.py

@@ -1,8 +1,8 @@
 from config import (
-    app_enable_api,
-    app_enable_auth_module,
-    app_enable_event_handler,
-    app_enable_rpc_server,
+    APP_ENABLE_API,
+    APP_ENABLE_AUTH_MODULE,
+    APP_ENABLE_EVENT_HANDLER,
+    APP_ENABLE_RPC_SERVER,
 )
 from integration.app.app import app
 from integration.log import logger
@@ -15,10 +15,10 @@ from module.auth.rpc import register_rpc
 
 
 def register_auth():
-    if not app_enable_auth_module:
+    if not APP_ENABLE_AUTH_MODULE:
         logger.info('🥪 Skip registering "auth"')
         return
-    if app_enable_api:
+    if APP_ENABLE_API:
         register_api(
             logger=logger,
             app=app,
@@ -26,11 +26,11 @@ def register_auth():
             rpc_caller=rpc_caller,
             publisher=publisher,
         )
-    if app_enable_event_handler:
+    if APP_ENABLE_EVENT_HANDLER:
         register_event(
             logger=logger, consumer=consumer, rpc_caller=rpc_caller, publisher=publisher
         )
-    if app_enable_rpc_server:
+    if APP_ENABLE_RPC_SERVER:
         register_rpc(
             logger=logger,
             rpc_server=rpc_server,

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/log/migrate.py

@@ -1,4 +1,4 @@
-from config import app_enable_log_module
+from config import APP_ENABLE_LOG_MODULE
 from helper.migration import migrate
 from integration.db_connection import engine
 from integration.log import logger
@@ -6,7 +6,7 @@ from module.log.integration import Base
 
 
 async def migrate_log():
-    if not app_enable_log_module:
+    if not APP_ENABLE_LOG_MODULE:
         logger.info('🥪 Skip DB migration for "log"')
         return
     logger.info('🥪 Perform DB migration for "log"')

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/log/register_module.py

@@ -1,8 +1,8 @@
 from config import (
-    app_enable_api,
-    app_enable_event_handler,
-    app_enable_log_module,
-    app_enable_rpc_server,
+    APP_ENABLE_API,
+    APP_ENABLE_EVENT_HANDLER,
+    APP_ENABLE_LOG_MODULE,
+    APP_ENABLE_RPC_SERVER,
 )
 from integration.app.app import app
 from integration.log import logger
@@ -15,10 +15,10 @@ from module.log.rpc import register_rpc
 
 
 def register_log():
-    if not app_enable_log_module:
+    if not APP_ENABLE_LOG_MODULE:
         logger.info('🥪 Skip registering "log"')
         return
-    if app_enable_api:
+    if APP_ENABLE_API:
         register_api(
             logger=logger,
             app=app,
@@ -26,11 +26,11 @@ def register_log():
             rpc_caller=rpc_caller,
             publisher=publisher,
         )
-    if app_enable_event_handler:
+    if APP_ENABLE_EVENT_HANDLER:
         register_event(
             logger=logger, consumer=consumer, rpc_caller=rpc_caller, publisher=publisher
         )
-    if app_enable_rpc_server:
+    if APP_ENABLE_RPC_SERVER:
         register_rpc(
             logger=logger,
             rpc_server=rpc_server,

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/template.env

@@ -10,8 +10,8 @@ APP_OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
 
 PUBLIC_BRAND=PascalZrbAppName
 PUBLIC_TITLE=PascalZrbAppName
-PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY=access_token
-PUBLIC_AUTH_REFRESH_TOKEN_COOKIE_KEY=refresh_token
+APP_AUTH_ACCESS_TOKEN_COOKIE_KEY=access_token
+APP_AUTH_REFRESH_TOKEN_COOKIE_KEY=refresh_token
 
 APP_AUTH_ACCESS_TOKEN_EXPIRE_SECONDS=300
 APP_AUTH_ACCESS_TOKEN_TYPE=jwt
@@ -36,6 +36,9 @@ APP_AUTH_GUEST_PHONE=
 APP_DB_CONNECTION=postgresql+psycopg2://postgres:admin@localhost:5432/snake_zrb_app_name
 APP_DB_ENGINE_SHOW_LOG=false
 APP_DB_AUTO_MIGRATE=true
+APP_DB_POOL_PRE_PING=true
+APP_DB_POOL_SIZE=20
+APP_DB_POOL_MAX_OVERFLOW=0
 
 APP_BROKER_TYPE=rabbitmq
 

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/test/auth/test_group_crud.py

@@ -2,7 +2,7 @@ from typing import AsyncIterator
 
 import pytest
 from httpx import AsyncClient
-from src.config import app_auth_admin_password, app_auth_admin_username
+from src.config import APP_AUTH_ADMIN_PASSWORD, APP_AUTH_ADMIN_USERNAME
 
 inserted_success_data = {
     "name": "test-create-group-success",
@@ -35,8 +35,8 @@ async def test_insert_group_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -88,8 +88,8 @@ async def test_update_group_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -155,8 +155,8 @@ async def test_delete_group_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/test/auth/test_permission_crud.py

@@ -2,7 +2,7 @@ from typing import AsyncIterator
 
 import pytest
 from httpx import AsyncClient
-from src.config import app_auth_admin_password, app_auth_admin_username
+from src.config import APP_AUTH_ADMIN_PASSWORD, APP_AUTH_ADMIN_USERNAME
 
 inserted_success_data = {
     "name": "test-create-permission-success",
@@ -31,8 +31,8 @@ async def test_insert_permission_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -84,8 +84,8 @@ async def test_update_permission_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
                 "permissions": [],
             },
         )
@@ -152,8 +152,8 @@ async def test_delete_permission_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/test/auth/test_user_crud.py

@@ -2,7 +2,7 @@ from typing import AsyncIterator
 
 import pytest
 from httpx import AsyncClient
-from src.config import app_auth_admin_password, app_auth_admin_username
+from src.config import APP_AUTH_ADMIN_PASSWORD, APP_AUTH_ADMIN_USERNAME
 
 inserted_success_data = {
     "username": "test-create-user-success",
@@ -51,8 +51,8 @@ async def test_insert_user_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -104,8 +104,8 @@ async def test_update_user_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -171,8 +171,8 @@ async def test_delete_user_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200