Enterprise agent platform for building, deploying, and operating AI teammates.
"""Unit tests for core/config.py configuration functions."""
import logging
import os
import subprocess
import sys
import tempfile
from pathlib import Path
from tempfile import gettempdir
import pytest
import xagent.config as config
from xagent.config import (
AGENT_RUNTIME,
APP_BASE_URL,
BACKGROUND_JOB_MAX_RETRIES,
BACKGROUND_JOB_STALE_SECONDS,
BACKGROUND_JOB_SWEEP_INTERVAL_SECONDS,
BACKGROUND_JOB_VISIBILITY_TIMEOUT_SECONDS,
BROWSER_CUA_DRIVER_COMMAND,
BROWSER_CUA_DRIVER_MAX_ELEMENTS,
BROWSER_CUA_DRIVER_SOCKET,
BROWSER_CUA_DRIVER_TIMEOUT_SECONDS,
CELERY_BROKER_URL,
CELERY_ENABLED,
CELERY_RESULT_BACKEND,
CORS_ORIGINS,
DATABASE_URL,
DB_MAX_OVERFLOW,
DB_POOL_SIZE,
DB_POOL_TIMEOUT_SECONDS,
DEEPDOC_XINFERENCE_API_KEY,
DEEPDOC_XINFERENCE_MODEL_UID,
DEEPDOC_XINFERENCE_PASSWORD,
DEEPDOC_XINFERENCE_TIMEOUT_SECONDS,
DEEPDOC_XINFERENCE_URL,
DEEPDOC_XINFERENCE_USERNAME,
EXTERNAL_MEDIA_URL_TTL_SECONDS,
EXTERNAL_SKILLS_LIBRARY_DIRS,
EXTERNAL_UPLOAD_DIRS,
FILE_DELIVERY_ACCEL_REDIRECT_ENABLED,
FILE_DELIVERY_ACCEL_REDIRECT_PREFIX,
FILE_DELIVERY_REDIRECT_ENABLED,
FILE_DELIVERY_SIGNED_URL_TTL_SECONDS,
FILE_MATERIALIZE_DIR,
FILE_STORAGE_OPTIONS,
FILE_STORAGE_STARTUP_SYNC_ENABLED,
FILE_STORAGE_URI,
FILE_STREAM_TICKET_TTL_SECONDS,
FORM_ANSWER_CONTINUATION_ENABLED,
FRONTEND_DIST_DIR,
GMAIL_PUBSUB_PROJECT_ID,
GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT,
GMAIL_PUBSUB_SUBSCRIPTION_PREFIX,
GMAIL_PUBSUB_TOPIC_PREFIX,
GMAIL_REGISTRATION_TIMEOUT_SECONDS,
HOT_PATH_CACHE_ENABLED,
HOT_PATH_CACHE_TTL_SECONDS,
HOT_PATH_TASK_CACHE_TTL_SECONDS,
KB_COLLECTIONS_TIMEOUT_SECONDS,
KB_MIGRATION_DEFER_BUDGET_SECONDS,
KB_MIGRATION_DEFER_DELAY_SECONDS,
KB_MILVUS_CLEANUP_ENABLED,
KB_MILVUS_CLEANUP_INTERVAL_SECONDS,
KB_SEARCH_TIMEOUT_SECONDS,
LANCEDB_PATH,
MAX_TRACE_PAYLOAD_BYTES,
MAX_UPLOAD_SIZE,
MCP_OAUTH_ALLOW_PRIVATE_HOSTS,
MCP_OAUTH_PROXY_URL,
MCP_TOOL_INIT_TIMEOUT_SECONDS,
NATIVE_BROWSER_APP_NAME,
NATIVE_BROWSER_ENABLED,
OPENROUTER_OFFICIAL_PROVIDERS_ONLY,
PASSWORD_RESET_EXPIRE_MINUTES,
PREVIEW_TMP_DIR,
PUBLIC_API_BASE_URL,
REDIS_URL,
S2S_API_BASE_URL,
SANDBOX_CPUS,
SANDBOX_ENV,
SANDBOX_HOST_PROJECT_ROOT,
SANDBOX_HOST_STORAGE_ROOT,
SANDBOX_IDLE_TTL,
SANDBOX_IMAGE,
SANDBOX_MAX_CONTAINERS,
SANDBOX_MEMORY,
SANDBOX_NAMESPACE,
SANDBOX_NETWORK,
SANDBOX_SWEEP_INTERVAL,
SANDBOX_TOOL_RUNNER,
SANDBOX_VOLUMES,
SANDBOX_WORKSPACE_MOUNT_MODE,
SANDBOX_WORKSPACE_VOLUME,
SANDBOX_WORKSPACE_VOLUME_ROOT,
SLACK_APP_TOKEN,
SLACK_CLIENT_ID,
SLACK_CLIENT_SECRET,
SLACK_REDIRECT_URI,
SMTP_FROM_EMAIL,
SMTP_FROM_NAME,
SMTP_HOST,
SMTP_PASSWORD,
SMTP_PORT,
SMTP_USE_SSL,
SMTP_USE_TLS,
SMTP_USERNAME,
STORAGE_ROOT,
TASK_LEASE_RECOVERY_BATCH_SIZE,
TASK_LEASE_RECOVERY_INTERVAL_SECONDS,
TASK_LEASE_TTL_SECONDS,
TASK_RUNTIME_HOOK_MAX_WORKERS,
TASK_RUNTIME_HOOK_QUEUE_TIMEOUT_SECONDS,
TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS,
TRIGGER_DISPATCHER_BATCH_SIZE,
TRIGGER_DISPATCHER_ENABLED,
TRIGGER_DISPATCHER_INTERVAL_SECONDS,
TRIGGER_DISPATCHER_STARTUP_JITTER_SECONDS,
TRUSTED_EGRESS_PROXY,
UPLOADED_FILE_RECOVERY_BATCH_SIZE,
UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS,
UPLOADED_FILE_RECOVERY_STALE_SECONDS,
UPLOADS_DIR,
WEB_CRAWL_TLS_IMPERSONATE,
WEB_DIR,
WEB_SEARCH_PROVIDER,
WEB_SEARCH_PROVIDERS,
XROUTER_EXCLUDED_MODELS,
ExternalUploadsDirConfigurationError,
format_file_size,
get_agent_pattern_for_execution_mode,
get_agent_runtime,
get_app_base_url,
get_background_job_max_retries,
get_background_job_stale_seconds,
get_background_job_sweep_interval_seconds,
get_background_job_visibility_timeout_seconds,
get_brave_search_country,
get_brave_search_endpoint,
get_browser_cua_driver_command,
get_browser_cua_driver_max_elements,
get_browser_cua_driver_socket,
get_browser_cua_driver_timeout_seconds,
get_celery_broker_url,
get_celery_enabled,
get_celery_result_backend,
get_cors_origins,
get_database_url,
get_db_max_overflow,
get_db_pool_size,
get_db_pool_timeout_seconds,
get_deepdoc_xinference_api_key,
get_deepdoc_xinference_model_uid,
get_deepdoc_xinference_password,
get_deepdoc_xinference_timeout_seconds,
get_deepdoc_xinference_url,
get_deepdoc_xinference_username,
get_default_sqlite_db_path,
get_default_task_execution_mode,
get_external_skills_dirs,
get_external_upload_dirs,
get_file_delivery_accel_redirect_enabled,
get_file_delivery_accel_redirect_prefix,
get_file_delivery_redirect_enabled,
get_file_delivery_signed_url_ttl_seconds,
get_file_materialize_dir,
get_file_storage_options,
get_file_storage_startup_sync_enabled,
get_file_storage_uri,
get_file_stream_ticket_ttl_seconds,
get_form_answer_continuation_enabled,
get_frontend_dist_dir,
get_gmail_pubsub_project_id,
get_gmail_pubsub_push_service_account,
get_gmail_pubsub_subscription_prefix,
get_gmail_pubsub_topic_prefix,
get_gmail_registration_timeout_seconds,
get_hot_path_cache_enabled,
get_hot_path_cache_ttl_seconds,
get_hot_path_task_cache_ttl_seconds,
get_kb_collections_timeout_seconds,
get_kb_migration_defer_budget_seconds,
get_kb_migration_defer_delay_seconds,
get_kb_milvus_cleanup_enabled,
get_kb_milvus_cleanup_interval_seconds,
get_kb_search_timeout_seconds,
get_lancedb_path,
get_max_trace_payload_bytes,
get_max_upload_size_bytes,
get_mcp_oauth_allow_private_hosts,
get_mcp_oauth_proxy_url,
get_mcp_tool_init_timeout_seconds,
get_native_browser_app_name,
get_native_browser_enabled,
get_openrouter_official_providers_only,
get_password_reset_expire_minutes,
get_preview_tmp_dir,
get_public_api_base_url,
get_redis_url,
get_s2s_api_base_url,
get_sandbox_cpus,
get_sandbox_env,
get_sandbox_host_project_root,
get_sandbox_host_storage_root,
get_sandbox_idle_ttl,
get_sandbox_image,
get_sandbox_max_containers,
get_sandbox_memory,
get_sandbox_namespace,
get_sandbox_network,
get_sandbox_sweep_interval,
get_sandbox_volumes,
get_sandbox_workspace_mount_mode,
get_sandbox_workspace_volume,
get_sandbox_workspace_volume_root,
get_slack_app_token,
get_slack_client_id,
get_slack_client_secret,
get_slack_oauth_redirect_uri,
get_smtp_from_email,
get_smtp_from_name,
get_smtp_host,
get_smtp_password,
get_smtp_port,
get_smtp_use_ssl,
get_smtp_use_tls,
get_smtp_username,
get_storage_root,
get_task_lease_recovery_batch_size,
get_task_lease_recovery_interval_seconds,
get_task_runtime_hook_max_workers,
get_task_runtime_hook_queue_timeout_seconds,
get_temp_file_cleanup_shutdown_timeout_seconds,
get_trigger_dispatcher_batch_size,
get_trigger_dispatcher_enabled,
get_trigger_dispatcher_interval_seconds,
get_trigger_dispatcher_startup_jitter_seconds,
get_trusted_egress_proxy_enabled,
get_uploaded_file_recovery_batch_size,
get_uploaded_file_recovery_interval_seconds,
get_uploaded_file_recovery_stale_seconds,
get_uploads_dir,
get_web_crawl_tls_impersonate,
get_web_dir,
get_web_search_provider,
get_xrouter_excluded_models,
in_sandbox_tool_runner,
validate_sandbox_namespace,
validate_sandbox_network,
)
@pytest.mark.parametrize("value", ["0", "-1", "garbage"])
def test_artifact_validation_byte_budget_invalid(monkeypatch, value):
monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", value)
with pytest.raises(ValueError):
config.get_artifact_validation_max_bytes()
@pytest.mark.parametrize("value", ["0", "-1", "nan", "inf", "garbage"])
def test_artifact_validation_timeout_invalid(monkeypatch, value):
monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_TIMEOUT_SECONDS", value)
with pytest.raises(ValueError):
config.get_artifact_validation_timeout_seconds()
def test_artifact_validation_defaults_and_overrides(monkeypatch):
monkeypatch.delenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", raising=False)
monkeypatch.delenv("XAGENT_ARTIFACT_VALIDATION_TIMEOUT_SECONDS", raising=False)
assert config.get_artifact_validation_max_bytes() == 32 * 1024 * 1024
assert config.get_artifact_validation_timeout_seconds() == 8
monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", "")
monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_TIMEOUT_SECONDS", "")
assert config.get_artifact_validation_max_bytes() == 32 * 1024 * 1024
assert config.get_artifact_validation_timeout_seconds() == 8
monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", "1024")
monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_TIMEOUT_SECONDS", "0.5")
assert config.get_artifact_validation_max_bytes() == 1024
assert config.get_artifact_validation_timeout_seconds() == 0.5
@pytest.mark.parametrize(
"value,expected",
[("32M", 32 * 1024**2), ("1.5MB", 1572864), ("512K", 524288), ("1024", 1024)],
)
def test_artifact_validation_and_upload_share_size_parser(monkeypatch, value, expected):
monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", value)
monkeypatch.setenv("XAGENT_MAX_UPLOAD_SIZE", value)
assert config.get_artifact_validation_max_bytes() == expected
assert config.get_max_upload_size_bytes() == expected
@pytest.mark.parametrize("value", ["inf", "infM", "nan", "nanM", "-1M"])
def test_artifact_validation_size_rejects_invalid_and_nonfinite(monkeypatch, value):
monkeypatch.setenv("XAGENT_ARTIFACT_VALIDATION_MAX_BYTES", value)
with pytest.raises(ValueError):
config.get_artifact_validation_max_bytes()
@pytest.mark.parametrize("value", [None, "false", "", "invalid", "true", "1", "ON"])
def test_google_scope_config(monkeypatch, value):
flag = "XAGENT_GOOGLE_RESTRICTED_SCOPES_ENABLED"
if value is None:
monkeypatch.delenv(flag, raising=False)
else:
monkeypatch.setenv(flag, value)
assert flag == config.GOOGLE_RESTRICTED_SCOPES_ENABLED
assert config.get_google_restricted_scopes() is (value in {"true", "1", "ON"})
@pytest.mark.parametrize("value", [None, "false", "", "invalid", "true", "1", "ON"])
def test_google_shared_oauth_grants_config(monkeypatch, value):
flag = "XAGENT_GOOGLE_SHARED_OAUTH_GRANTS_ENABLED"
if value is None:
monkeypatch.delenv(flag, raising=False)
else:
monkeypatch.setenv(flag, value)
assert flag == config.GOOGLE_SHARED_OAUTH_GRANTS_ENABLED
assert config.get_google_shared_oauth_grants_enabled() is (
value in {"true", "1", "ON"}
)
@pytest.mark.parametrize("value", [None, "false", "", "invalid", "true", "1", "ON"])
def test_zoom_meeting_write_config(monkeypatch, value):
flag = "XAGENT_ZOOM_MEETING_WRITE_ENABLED"
if value is None:
monkeypatch.delenv(flag, raising=False)
else:
monkeypatch.setenv(flag, value)
assert flag == config.ZOOM_MEETING_WRITE_ENABLED
assert config.get_zoom_meeting_write_enabled() is (value in {"true", "1", "ON"})
class TestEnvironmentVariableConstants:
"""Test environment variable constant names."""
def test_upload_dir_constant(self):
assert UPLOADS_DIR == "XAGENT_UPLOADS_DIR"
def test_web_dir_constant(self):
assert WEB_DIR == "XAGENT_WEB_DIR"
def test_frontend_dist_dir_constant(self):
assert FRONTEND_DIST_DIR == "XAGENT_FRONTEND_DIST_DIR"
def test_external_upload_dirs_constant(self):
assert EXTERNAL_UPLOAD_DIRS == "XAGENT_EXTERNAL_UPLOAD_DIRS"
def test_external_skills_dirs_constant(self):
assert EXTERNAL_SKILLS_LIBRARY_DIRS == "XAGENT_EXTERNAL_SKILLS_LIBRARY_DIRS"
def test_agent_runtime_constant(self):
assert AGENT_RUNTIME == "XAGENT_AGENT_RUNTIME"
def test_storage_root_constant(self):
assert STORAGE_ROOT == "XAGENT_STORAGE_ROOT"
def test_local_browser_constants(self):
assert NATIVE_BROWSER_ENABLED == "XAGENT_NATIVE_BROWSER_ENABLED"
assert NATIVE_BROWSER_APP_NAME == "XAGENT_NATIVE_BROWSER_APP_NAME"
assert BROWSER_CUA_DRIVER_COMMAND == "XAGENT_BROWSER_CUA_DRIVER_COMMAND"
assert BROWSER_CUA_DRIVER_SOCKET == "XAGENT_BROWSER_CUA_DRIVER_SOCKET"
assert (
BROWSER_CUA_DRIVER_TIMEOUT_SECONDS
== "XAGENT_BROWSER_CUA_DRIVER_TIMEOUT_SECONDS"
)
assert (
BROWSER_CUA_DRIVER_MAX_ELEMENTS == "XAGENT_BROWSER_CUA_DRIVER_MAX_ELEMENTS"
)
def test_sandbox_image_constant(self):
assert SANDBOX_IMAGE == "SANDBOX_IMAGE"
def test_sandbox_host_project_root_constant(self):
assert SANDBOX_HOST_PROJECT_ROOT == "XAGENT_SANDBOX_HOST_PROJECT_ROOT"
def test_sandbox_namespace_constant(self):
assert SANDBOX_NAMESPACE == "XAGENT_SANDBOX_NAMESPACE"
def test_sandbox_network_constant(self):
assert SANDBOX_NETWORK == "XAGENT_SANDBOX_NETWORK"
def test_sandbox_host_storage_root_constant(self):
assert SANDBOX_HOST_STORAGE_ROOT == "XAGENT_SANDBOX_HOST_STORAGE_ROOT"
def test_sandbox_tool_runner_constant(self):
assert SANDBOX_TOOL_RUNNER == "XAGENT_SANDBOX_TOOL_RUNNER"
def test_in_sandbox_tool_runner_defaults_to_false(self):
assert in_sandbox_tool_runner() is False
def test_in_sandbox_tool_runner_reads_the_env_at_process_start(self, monkeypatch):
for value, expected in (
("1", True),
("true", True),
("yes", True),
("on", True),
("0", False),
("false", False),
("no", False),
("off", False),
("", False),
):
monkeypatch.setenv(SANDBOX_TOOL_RUNNER, value)
assert config._get_bool_env(SANDBOX_TOOL_RUNNER, False) is expected
def test_in_sandbox_tool_runner_ignores_later_env_mutation(self, monkeypatch):
"""Agent-authored code runs late; it must not flip the whole process."""
monkeypatch.setenv(SANDBOX_TOOL_RUNNER, "1")
assert in_sandbox_tool_runner() is False
def test_in_sandbox_tool_runner_does_read_the_env_at_import(self):
"""The other tests patch the snapshot, so pin that it is populated."""
probe = "import xagent.config as c; print(c.in_sandbox_tool_runner())"
env = {**os.environ, SANDBOX_TOOL_RUNNER: "1"}
proc = subprocess.run(
[sys.executable, "-c", probe],
capture_output=True,
text=True,
env=env,
check=True,
)
assert proc.stdout.strip() == "True"
def test_lancedb_path_constant(self):
assert LANCEDB_PATH == "LANCEDB_PATH"
def test_database_url_constant(self):
assert DATABASE_URL == "DATABASE_URL"
def test_task_lease_recovery_constants(self):
assert (
TASK_LEASE_RECOVERY_INTERVAL_SECONDS
== "XAGENT_TASK_LEASE_RECOVERY_INTERVAL_SECONDS"
)
assert TASK_LEASE_RECOVERY_BATCH_SIZE == "XAGENT_TASK_LEASE_RECOVERY_BATCH_SIZE"
def test_uploaded_file_recovery_constants(self):
assert (
UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS
== "XAGENT_UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS"
)
assert (
UPLOADED_FILE_RECOVERY_STALE_SECONDS
== "XAGENT_UPLOADED_FILE_RECOVERY_STALE_SECONDS"
)
assert (
UPLOADED_FILE_RECOVERY_BATCH_SIZE
== "XAGENT_UPLOADED_FILE_RECOVERY_BATCH_SIZE"
)
def test_max_upload_size_constant(self):
assert MAX_UPLOAD_SIZE == "XAGENT_MAX_UPLOAD_SIZE"
def test_web_search_provider_constant(self):
assert WEB_SEARCH_PROVIDER == "XAGENT_WEB_SEARCH_PROVIDER"
def test_web_crawl_tls_impersonate_constant(self):
assert WEB_CRAWL_TLS_IMPERSONATE == "XAGENT_WEB_CRAWL_TLS_IMPERSONATE"
def test_openrouter_official_providers_only_constant(self):
assert (
OPENROUTER_OFFICIAL_PROVIDERS_ONLY
== "XAGENT_OPENROUTER_OFFICIAL_PROVIDERS_ONLY"
)
def test_xrouter_excluded_models_constant(self):
assert XROUTER_EXCLUDED_MODELS == "XAGENT_XROUTER_EXCLUDED_MODELS"
def test_mcp_oauth_allow_private_hosts_constant(self):
assert MCP_OAUTH_ALLOW_PRIVATE_HOSTS == "XAGENT_MCP_OAUTH_ALLOW_PRIVATE_HOSTS"
def test_mcp_oauth_proxy_url_constant(self):
assert MCP_OAUTH_PROXY_URL == "XAGENT_MCP_OAUTH_PROXY_URL"
def test_file_storage_uri_constant(self):
assert FILE_STORAGE_URI == "XAGENT_FILE_STORAGE_URI"
def test_file_storage_options_constant(self):
assert FILE_STORAGE_OPTIONS == "XAGENT_FILE_STORAGE_OPTIONS"
def test_file_materialize_dir_constant(self):
assert FILE_MATERIALIZE_DIR == "XAGENT_FILE_MATERIALIZE_DIR"
def test_preview_tmp_dir_constant(self):
assert PREVIEW_TMP_DIR == "XAGENT_PREVIEW_TMP_DIR"
def test_file_storage_startup_sync_enabled_constant(self):
assert (
FILE_STORAGE_STARTUP_SYNC_ENABLED
== "XAGENT_FILE_STORAGE_STARTUP_SYNC_ENABLED"
)
def test_file_delivery_accel_redirect_constants(self):
assert (
FILE_DELIVERY_ACCEL_REDIRECT_ENABLED
== "XAGENT_FILE_DELIVERY_ACCEL_REDIRECT_ENABLED"
)
assert (
FILE_DELIVERY_ACCEL_REDIRECT_PREFIX
== "XAGENT_FILE_DELIVERY_ACCEL_REDIRECT_PREFIX"
)
def test_redis_url_constant(self):
assert REDIS_URL == "XAGENT_REDIS_URL"
def test_hot_path_cache_constants(self):
assert HOT_PATH_CACHE_ENABLED == "XAGENT_HOT_PATH_CACHE_ENABLED"
assert HOT_PATH_CACHE_TTL_SECONDS == "XAGENT_HOT_PATH_CACHE_TTL_SECONDS"
assert (
HOT_PATH_TASK_CACHE_TTL_SECONDS == "XAGENT_HOT_PATH_TASK_CACHE_TTL_SECONDS"
)
def test_celery_background_job_constants(self):
assert CELERY_ENABLED == "XAGENT_CELERY_ENABLED"
assert CELERY_BROKER_URL == "XAGENT_CELERY_BROKER_URL"
assert CELERY_RESULT_BACKEND == "XAGENT_CELERY_RESULT_BACKEND"
assert (
BACKGROUND_JOB_VISIBILITY_TIMEOUT_SECONDS
== "XAGENT_BACKGROUND_JOB_VISIBILITY_TIMEOUT_SECONDS"
)
assert BACKGROUND_JOB_MAX_RETRIES == "XAGENT_BACKGROUND_JOB_MAX_RETRIES"
assert BACKGROUND_JOB_STALE_SECONDS == "XAGENT_BACKGROUND_JOB_STALE_SECONDS"
assert (
BACKGROUND_JOB_SWEEP_INTERVAL_SECONDS
== "XAGENT_BACKGROUND_JOB_SWEEP_INTERVAL_SECONDS"
)
assert (
KB_MIGRATION_DEFER_DELAY_SECONDS
== "XAGENT_KB_MIGRATION_DEFER_DELAY_SECONDS"
)
assert (
KB_MIGRATION_DEFER_BUDGET_SECONDS
== "XAGENT_KB_MIGRATION_DEFER_BUDGET_SECONDS"
)
assert TRIGGER_DISPATCHER_ENABLED == "XAGENT_TRIGGER_DISPATCHER_ENABLED"
assert (
TRIGGER_DISPATCHER_INTERVAL_SECONDS
== "XAGENT_TRIGGER_DISPATCHER_INTERVAL_SECONDS"
)
assert TRIGGER_DISPATCHER_BATCH_SIZE == "XAGENT_TRIGGER_DISPATCHER_BATCH_SIZE"
def test_auth_email_config_constants(self):
assert PASSWORD_RESET_EXPIRE_MINUTES == "XAGENT_PASSWORD_RESET_EXPIRE_MINUTES"
assert APP_BASE_URL == "XAGENT_APP_BASE_URL"
assert SMTP_HOST == "XAGENT_SMTP_HOST"
assert SMTP_PORT == "XAGENT_SMTP_PORT"
assert SMTP_USERNAME == "XAGENT_SMTP_USERNAME"
assert SMTP_PASSWORD == "XAGENT_SMTP_PASSWORD"
assert SMTP_USE_TLS == "XAGENT_SMTP_USE_TLS"
assert SMTP_USE_SSL == "XAGENT_SMTP_USE_SSL"
assert SMTP_FROM_EMAIL == "XAGENT_SMTP_FROM_EMAIL"
assert SMTP_FROM_NAME == "XAGENT_SMTP_FROM_NAME"
def test_slack_oauth_config_constants(self):
assert SLACK_CLIENT_ID == "XAGENT_SLACK_CLIENT_ID"
assert SLACK_CLIENT_SECRET == "XAGENT_SLACK_CLIENT_SECRET"
assert SLACK_APP_TOKEN == "XAGENT_SLACK_APP_TOKEN"
assert SLACK_REDIRECT_URI == "XAGENT_SLACK_REDIRECT_URI"
class TestAuthEmailConfig:
def test_password_reset_expire_minutes_defaults_to_30(self, monkeypatch):
monkeypatch.delenv(PASSWORD_RESET_EXPIRE_MINUTES, raising=False)
assert get_password_reset_expire_minutes() == 30
@pytest.mark.parametrize("value", ["abc", "0", "-5"])
def test_password_reset_expire_minutes_invalid_values_fall_back(
self, monkeypatch, value
):
monkeypatch.setenv(PASSWORD_RESET_EXPIRE_MINUTES, value)
assert get_password_reset_expire_minutes() == 30
def test_app_base_url_returns_none_when_unset_or_blank(self, monkeypatch):
monkeypatch.delenv(APP_BASE_URL, raising=False)
assert get_app_base_url() is None
monkeypatch.setenv(APP_BASE_URL, " ")
assert get_app_base_url() is None
def test_app_base_url_strips_and_removes_trailing_slash(self, monkeypatch):
monkeypatch.setenv(APP_BASE_URL, " https://app.example.com/base/ ")
assert get_app_base_url() == "https://app.example.com/base"
def test_slack_oauth_config_defaults_to_unconfigured(self, monkeypatch):
for env_name in (
SLACK_CLIENT_ID,
SLACK_CLIENT_SECRET,
SLACK_APP_TOKEN,
SLACK_REDIRECT_URI,
PUBLIC_API_BASE_URL,
):
monkeypatch.delenv(env_name, raising=False)
assert get_slack_client_id() is None
assert get_slack_client_secret() is None
assert get_slack_app_token() is None
assert get_slack_oauth_redirect_uri() is None
def test_cors_origins_default_to_frontend_url(self, monkeypatch):
monkeypatch.delenv(CORS_ORIGINS, raising=False)
monkeypatch.setenv("XAGENT_FRONTEND_URL", " https://app.example.com/ ")
assert get_cors_origins() == ["https://app.example.com"]
def test_cors_origins_parse_explicit_list(self, monkeypatch):
monkeypatch.setenv(
CORS_ORIGINS,
" https://app.example.com/ , https://admin.example.com ",
)
assert get_cors_origins() == [
"https://app.example.com",
"https://admin.example.com",
]
def test_cors_origins_treat_blank_as_unset(self, monkeypatch):
monkeypatch.setenv(CORS_ORIGINS, "")
monkeypatch.setenv("XAGENT_FRONTEND_URL", "https://app.example.com")
assert get_cors_origins() == ["https://app.example.com"]
def test_cors_origins_reject_wildcard_with_credentials(self, monkeypatch):
monkeypatch.setenv(CORS_ORIGINS, "*")
with pytest.raises(ValueError, match=r"cannot contain '\*'"):
get_cors_origins()
def test_slack_oauth_config_uses_explicit_values(self, monkeypatch):
monkeypatch.setenv(SLACK_CLIENT_ID, " client-id ")
monkeypatch.setenv(SLACK_CLIENT_SECRET, " client-secret ")
monkeypatch.setenv(SLACK_APP_TOKEN, " xapp-test ")
monkeypatch.setenv(
SLACK_REDIRECT_URI,
" https://api.example.com/api/channels/slack/oauth/callback/ ",
)
assert get_slack_client_id() == "client-id"
assert get_slack_client_secret() == "client-secret"
assert get_slack_app_token() == "xapp-test"
assert (
get_slack_oauth_redirect_uri()
== "https://api.example.com/api/channels/slack/oauth/callback"
)
def test_slack_redirect_uri_falls_back_to_public_api_base(self, monkeypatch):
monkeypatch.delenv(SLACK_REDIRECT_URI, raising=False)
monkeypatch.setenv(PUBLIC_API_BASE_URL, " https://api.example.com/ ")
assert (
get_slack_oauth_redirect_uri()
== "https://api.example.com/api/channels/slack/oauth/callback"
)
def test_smtp_host_and_credentials_strip_expected_values(self, monkeypatch):
monkeypatch.setenv(SMTP_HOST, " smtp.example.com ")
monkeypatch.setenv(SMTP_USERNAME, " user ")
monkeypatch.setenv(SMTP_PASSWORD, "secret ")
monkeypatch.setenv(SMTP_FROM_EMAIL, " [email protected] ")
assert get_smtp_host() == "smtp.example.com"
assert get_smtp_username() == "user"
assert get_smtp_password() == "secret "
assert get_smtp_from_email() == "[email protected]"
def test_smtp_port_defaults_and_invalid_values_fall_back(self, monkeypatch):
monkeypatch.delenv(SMTP_PORT, raising=False)
assert get_smtp_port() == 587
monkeypatch.setenv(SMTP_PORT, "abc")
assert get_smtp_port() == 587
monkeypatch.setenv(SMTP_PORT, "0")
assert get_smtp_port() == 587
@pytest.mark.parametrize(
"env_var,getter,default,true_value,false_value",
[
(SMTP_USE_TLS, get_smtp_use_tls, True, "true", "false"),
(SMTP_USE_SSL, get_smtp_use_ssl, False, "yes", "off"),
],
)
def test_smtp_bool_settings(
self, monkeypatch, env_var, getter, default, true_value, false_value
):
monkeypatch.delenv(env_var, raising=False)
assert getter() is default
monkeypatch.setenv(env_var, true_value)
assert getter() is True
monkeypatch.setenv(env_var, false_value)
assert getter() is False
def test_smtp_from_name_uses_default_and_trimmed_override(self, monkeypatch):
monkeypatch.delenv(SMTP_FROM_NAME, raising=False)
assert get_smtp_from_name("Xagent") == "Xagent"
monkeypatch.setenv(SMTP_FROM_NAME, " Support Team ")
assert get_smtp_from_name("Xagent") == "Support Team"
class TestOpenRouterConfig:
def test_official_providers_only_defaults_false(self, monkeypatch):
monkeypatch.delenv(OPENROUTER_OFFICIAL_PROVIDERS_ONLY, raising=False)
assert get_openrouter_official_providers_only() is False
@pytest.mark.parametrize("value", ["true", "1", "yes", "on", " TRUE "])
def test_official_providers_only_true_values(self, monkeypatch, value):
monkeypatch.setenv(OPENROUTER_OFFICIAL_PROVIDERS_ONLY, value)
assert get_openrouter_official_providers_only() is True
@pytest.mark.parametrize("value", ["false", "0", "no", "off", "", "unknown"])
def test_official_providers_only_false_values(self, monkeypatch, value):
monkeypatch.setenv(OPENROUTER_OFFICIAL_PROVIDERS_ONLY, value)
assert get_openrouter_official_providers_only() is False
def test_xrouter_excluded_models_defaults_empty(self, monkeypatch):
monkeypatch.delenv(XROUTER_EXCLUDED_MODELS, raising=False)
assert get_xrouter_excluded_models() == ()
def test_xrouter_excluded_models_parses_and_deduplicates(self, monkeypatch):
monkeypatch.setenv(
XROUTER_EXCLUDED_MODELS,
" z-ai/glm-5.3-flash, openai/gpt-5.6-luna, z-ai/glm-5.3-flash,, ",
)
assert get_xrouter_excluded_models() == (
"z-ai/glm-5.3-flash",
"openai/gpt-5.6-luna",
)
class TestFormAnswerContinuationConfig:
@pytest.mark.parametrize(
("value", "expected"),
[
pytest.param(None, True, id="unset-is-on"),
pytest.param("true", True, id="true"),
pytest.param(" TRUE ", True, id="true-padded-uppercase"),
pytest.param("1", True, id="one"),
pytest.param("false", False, id="false"),
pytest.param("0", False, id="zero"),
pytest.param("", False, id="empty-is-off"),
],
)
def test_env_table(self, monkeypatch, value, expected):
if value is None:
monkeypatch.delenv(FORM_ANSWER_CONTINUATION_ENABLED, raising=False)
else:
monkeypatch.setenv(FORM_ANSWER_CONTINUATION_ENABLED, value)
assert get_form_answer_continuation_enabled() is expected
def test_env_var_name_constant(self):
assert (
FORM_ANSWER_CONTINUATION_ENABLED
== "XAGENT_FORM_ANSWER_CONTINUATION_ENABLED"
)
class TestMCPOAuthConfig:
def test_allow_private_hosts_defaults_false(self, monkeypatch):
monkeypatch.delenv(MCP_OAUTH_ALLOW_PRIVATE_HOSTS, raising=False)
assert get_mcp_oauth_allow_private_hosts() is False
@pytest.mark.parametrize("value", ["true", "1", "yes", "on", " TRUE "])
def test_allow_private_hosts_true_values(self, monkeypatch, value):
monkeypatch.setenv(MCP_OAUTH_ALLOW_PRIVATE_HOSTS, value)
assert get_mcp_oauth_allow_private_hosts() is True
@pytest.mark.parametrize("value", ["false", "0", "no", "off", "", "unknown"])
def test_allow_private_hosts_false_values(self, monkeypatch, value):
monkeypatch.setenv(MCP_OAUTH_ALLOW_PRIVATE_HOSTS, value)
assert get_mcp_oauth_allow_private_hosts() is False
def test_proxy_url_returns_none_when_unset_or_blank(self, monkeypatch):
monkeypatch.delenv(MCP_OAUTH_PROXY_URL, raising=False)
assert get_mcp_oauth_proxy_url() is None
monkeypatch.setenv(MCP_OAUTH_PROXY_URL, " ")
assert get_mcp_oauth_proxy_url() is None
def test_proxy_url_accepts_absolute_http_proxy(self, monkeypatch):
monkeypatch.setenv(MCP_OAUTH_PROXY_URL, " http://proxy.example.com:8080 ")
assert get_mcp_oauth_proxy_url() == "http://proxy.example.com:8080"
@pytest.mark.parametrize("value", ["proxy.example.com:8080", "socks5://proxy:1080"])
def test_proxy_url_rejects_unsupported_values(self, monkeypatch, value):
monkeypatch.setenv(MCP_OAUTH_PROXY_URL, value)
with pytest.raises(ValueError, match="XAGENT_MCP_OAUTH_PROXY_URL"):
get_mcp_oauth_proxy_url()
def test_hubspot_credentials_are_trimmed(self, monkeypatch):
monkeypatch.setenv(config.HUBSPOT_MCP_CLIENT_ID, " client-id ")
monkeypatch.setenv(config.HUBSPOT_MCP_CLIENT_SECRET, " client-secret ")
assert config.get_hubspot_mcp_client_id() == "client-id"
assert config.get_hubspot_mcp_client_secret() == "client-secret"
def test_hubspot_credentials_default_none(self, monkeypatch):
monkeypatch.delenv(config.HUBSPOT_MCP_CLIENT_ID, raising=False)
monkeypatch.delenv(config.HUBSPOT_MCP_CLIENT_SECRET, raising=False)
assert config.get_hubspot_mcp_client_id() is None
assert config.get_hubspot_mcp_client_secret() is None
class TestTrustedEgressProxyConfig:
def test_trusted_egress_proxy_constant(self):
assert TRUSTED_EGRESS_PROXY == "XAGENT_TRUSTED_EGRESS_PROXY"
def test_trusted_egress_proxy_defaults_false(self, monkeypatch):
monkeypatch.delenv(TRUSTED_EGRESS_PROXY, raising=False)
assert get_trusted_egress_proxy_enabled() is False
@pytest.mark.parametrize("value", ["true", "1", "yes", "on", " TRUE "])
def test_trusted_egress_proxy_true_values(self, monkeypatch, value):
monkeypatch.setenv(TRUSTED_EGRESS_PROXY, value)
assert get_trusted_egress_proxy_enabled() is True
@pytest.mark.parametrize("value", ["false", "0", "no", "off", "", "unknown"])
def test_trusted_egress_proxy_false_values(self, monkeypatch, value):
monkeypatch.setenv(TRUSTED_EGRESS_PROXY, value)
assert get_trusted_egress_proxy_enabled() is False
class TestHotPathCacheConfig:
def test_redis_url_empty_is_none(self, monkeypatch):
monkeypatch.delenv(REDIS_URL, raising=False)
assert get_redis_url() is None
monkeypatch.setenv(REDIS_URL, " ")
assert get_redis_url() is None
def test_redis_url_strips_value(self, monkeypatch):
monkeypatch.setenv(REDIS_URL, " redis://localhost:6379/0 ")
assert get_redis_url() == "redis://localhost:6379/0"
def test_hot_path_cache_enabled_defaults_true(self, monkeypatch):
monkeypatch.delenv(HOT_PATH_CACHE_ENABLED, raising=False)
assert get_hot_path_cache_enabled() is True
def test_hot_path_cache_enabled_false(self, monkeypatch):
monkeypatch.setenv(HOT_PATH_CACHE_ENABLED, "false")
assert get_hot_path_cache_enabled() is False
def test_hot_path_ttls(self, monkeypatch):
monkeypatch.delenv(HOT_PATH_CACHE_TTL_SECONDS, raising=False)
monkeypatch.delenv(HOT_PATH_TASK_CACHE_TTL_SECONDS, raising=False)
assert get_hot_path_cache_ttl_seconds() == 30
assert get_hot_path_task_cache_ttl_seconds() == 30
monkeypatch.setenv(HOT_PATH_CACHE_TTL_SECONDS, "45")
monkeypatch.setenv(HOT_PATH_TASK_CACHE_TTL_SECONDS, "3")
assert get_hot_path_cache_ttl_seconds() == 45
assert get_hot_path_task_cache_ttl_seconds() == 3
class TestCeleryBackgroundJobConfig:
def test_celery_disabled_by_default(self, monkeypatch):
monkeypatch.delenv(CELERY_ENABLED, raising=False)
assert get_celery_enabled() is False
def test_celery_enabled_true_values(self, monkeypatch):
monkeypatch.setenv(CELERY_ENABLED, "yes")
assert get_celery_enabled() is True
def test_celery_broker_explicit(self, monkeypatch):
monkeypatch.setenv(CELERY_BROKER_URL, " redis://localhost:6379/7 ")
monkeypatch.setenv(REDIS_URL, "redis://localhost:6379/0")
assert get_celery_broker_url() == "redis://localhost:6379/7"
def test_celery_broker_derives_from_redis_url_db1(self, monkeypatch):
monkeypatch.delenv(CELERY_BROKER_URL, raising=False)
monkeypatch.setenv(REDIS_URL, "redis://localhost:6379/0")
assert get_celery_broker_url() == "redis://localhost:6379/1"
def test_celery_broker_none_without_redis(self, monkeypatch):
monkeypatch.delenv(CELERY_BROKER_URL, raising=False)
monkeypatch.delenv(REDIS_URL, raising=False)
assert get_celery_broker_url() is None
def test_celery_result_backend_optional(self, monkeypatch):
monkeypatch.delenv(CELERY_RESULT_BACKEND, raising=False)
assert get_celery_result_backend() is None
monkeypatch.setenv(CELERY_RESULT_BACKEND, " redis://localhost:6379/2 ")
assert get_celery_result_backend() == "redis://localhost:6379/2"
def test_background_job_tuning_defaults(self, monkeypatch):
monkeypatch.delenv(BACKGROUND_JOB_VISIBILITY_TIMEOUT_SECONDS, raising=False)
monkeypatch.delenv(BACKGROUND_JOB_MAX_RETRIES, raising=False)
monkeypatch.delenv(BACKGROUND_JOB_STALE_SECONDS, raising=False)
monkeypatch.delenv(BACKGROUND_JOB_SWEEP_INTERVAL_SECONDS, raising=False)
assert get_background_job_visibility_timeout_seconds() == 3600
assert get_background_job_max_retries() == 3
assert get_background_job_stale_seconds() == 7200
assert get_background_job_sweep_interval_seconds() == 300
def test_kb_migration_defer_defaults(self, monkeypatch):
monkeypatch.delenv(KB_MIGRATION_DEFER_DELAY_SECONDS, raising=False)
monkeypatch.delenv(KB_MIGRATION_DEFER_BUDGET_SECONDS, raising=False)
assert get_kb_migration_defer_delay_seconds() == 15
assert get_kb_migration_defer_budget_seconds() == 600
def test_kb_migration_defer_env_overrides(self, monkeypatch):
monkeypatch.setenv(KB_MIGRATION_DEFER_DELAY_SECONDS, "20")
monkeypatch.setenv(KB_MIGRATION_DEFER_BUDGET_SECONDS, "1200")
assert get_kb_migration_defer_delay_seconds() == 20
assert get_kb_migration_defer_budget_seconds() == 1200
def test_kb_milvus_cleanup_interval_default(self, monkeypatch):
monkeypatch.delenv(KB_MILVUS_CLEANUP_INTERVAL_SECONDS, raising=False)
assert get_kb_milvus_cleanup_interval_seconds() == 3600
def test_kb_milvus_cleanup_interval_env_override(self, monkeypatch):
monkeypatch.setenv(KB_MILVUS_CLEANUP_INTERVAL_SECONDS, "600")
assert get_kb_milvus_cleanup_interval_seconds() == 600
def test_kb_milvus_cleanup_interval_below_minimum_falls_back_to_default(
self, monkeypatch
):
monkeypatch.setenv(KB_MILVUS_CLEANUP_INTERVAL_SECONDS, "299")
assert get_kb_milvus_cleanup_interval_seconds() == 3600
def test_kb_milvus_cleanup_enabled_defaults_to_true(self, monkeypatch):
monkeypatch.delenv(KB_MILVUS_CLEANUP_ENABLED, raising=False)
assert get_kb_milvus_cleanup_enabled() is True
@pytest.mark.parametrize("value", ["false", "0", "no", "off", "FALSE", " false "])
def test_kb_milvus_cleanup_enabled_false_values(self, monkeypatch, value):
monkeypatch.setenv(KB_MILVUS_CLEANUP_ENABLED, value)
assert get_kb_milvus_cleanup_enabled() is False
def test_kb_milvus_cleanup_enabled_true_value(self, monkeypatch):
monkeypatch.setenv(KB_MILVUS_CLEANUP_ENABLED, "true")
assert get_kb_milvus_cleanup_enabled() is True
def test_trigger_dispatcher_tuning(self, monkeypatch):
monkeypatch.delenv(TRIGGER_DISPATCHER_ENABLED, raising=False)
monkeypatch.delenv(TRIGGER_DISPATCHER_INTERVAL_SECONDS, raising=False)
monkeypatch.delenv(TRIGGER_DISPATCHER_BATCH_SIZE, raising=False)
monkeypatch.delenv(TRIGGER_DISPATCHER_STARTUP_JITTER_SECONDS, raising=False)
assert get_trigger_dispatcher_enabled() is True
assert get_trigger_dispatcher_interval_seconds() == 5
assert get_trigger_dispatcher_batch_size() == 20
assert get_trigger_dispatcher_startup_jitter_seconds() == 30
monkeypatch.setenv(TRIGGER_DISPATCHER_ENABLED, "false")
monkeypatch.setenv(TRIGGER_DISPATCHER_INTERVAL_SECONDS, "9")
monkeypatch.setenv(TRIGGER_DISPATCHER_BATCH_SIZE, "3")
monkeypatch.setenv(TRIGGER_DISPATCHER_STARTUP_JITTER_SECONDS, "0")
assert get_trigger_dispatcher_enabled() is False
assert get_trigger_dispatcher_interval_seconds() == 9
assert get_trigger_dispatcher_batch_size() == 3
assert get_trigger_dispatcher_startup_jitter_seconds() == 0
def test_task_lease_recovery_tuning(self, monkeypatch):
monkeypatch.setenv(TASK_LEASE_TTL_SECONDS, "60")
monkeypatch.delenv(TASK_LEASE_RECOVERY_INTERVAL_SECONDS, raising=False)
monkeypatch.delenv(TASK_LEASE_RECOVERY_BATCH_SIZE, raising=False)
assert get_task_lease_recovery_interval_seconds() == 20
assert get_task_lease_recovery_batch_size() == 100
monkeypatch.setenv(TASK_LEASE_RECOVERY_INTERVAL_SECONDS, "7")
monkeypatch.setenv(TASK_LEASE_RECOVERY_BATCH_SIZE, "3")
assert get_task_lease_recovery_interval_seconds() == 7
assert get_task_lease_recovery_batch_size() == 3
monkeypatch.setenv(TASK_LEASE_RECOVERY_INTERVAL_SECONDS, "")
monkeypatch.setenv(TASK_LEASE_RECOVERY_BATCH_SIZE, "0")
assert get_task_lease_recovery_interval_seconds() == 20
assert get_task_lease_recovery_batch_size() == 100
def test_uploaded_file_recovery_tuning(self, monkeypatch):
monkeypatch.delenv(UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS, raising=False)
monkeypatch.delenv(UPLOADED_FILE_RECOVERY_STALE_SECONDS, raising=False)
monkeypatch.delenv(UPLOADED_FILE_RECOVERY_BATCH_SIZE, raising=False)
assert get_uploaded_file_recovery_interval_seconds() == 60
assert get_uploaded_file_recovery_stale_seconds() == 300
assert get_uploaded_file_recovery_batch_size() == 100
monkeypatch.setenv(UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS, "7")
monkeypatch.setenv(UPLOADED_FILE_RECOVERY_STALE_SECONDS, "45")
monkeypatch.setenv(UPLOADED_FILE_RECOVERY_BATCH_SIZE, "3")
assert get_uploaded_file_recovery_interval_seconds() == 7
assert get_uploaded_file_recovery_stale_seconds() == 45
assert get_uploaded_file_recovery_batch_size() == 3
monkeypatch.setenv(UPLOADED_FILE_RECOVERY_INTERVAL_SECONDS, "")
monkeypatch.setenv(UPLOADED_FILE_RECOVERY_STALE_SECONDS, "0")
monkeypatch.setenv(UPLOADED_FILE_RECOVERY_BATCH_SIZE, "-1")
assert get_uploaded_file_recovery_interval_seconds() == 60
assert get_uploaded_file_recovery_stale_seconds() == 300
assert get_uploaded_file_recovery_batch_size() == 100
def test_temp_file_cleanup_shutdown_timeout_tuning(self, monkeypatch):
assert (
TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS
== "XAGENT_TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS"
)
monkeypatch.delenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, raising=False)
assert get_temp_file_cleanup_shutdown_timeout_seconds() == 10
monkeypatch.setenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, "45")
assert get_temp_file_cleanup_shutdown_timeout_seconds() == 45
# Invalid / non-positive values fall back to the default.
monkeypatch.setenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, "0")
assert get_temp_file_cleanup_shutdown_timeout_seconds() == 10
monkeypatch.setenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, "abc")
assert get_temp_file_cleanup_shutdown_timeout_seconds() == 10
monkeypatch.setenv(TEMP_FILE_CLEANUP_SHUTDOWN_TIMEOUT_SECONDS, "-5")
assert get_temp_file_cleanup_shutdown_timeout_seconds() == 10
class TestGetWebSearchProvider:
"""Test get_web_search_provider() function."""
def test_default_web_search_provider(self, monkeypatch):
monkeypatch.delenv(WEB_SEARCH_PROVIDER, raising=False)
assert get_web_search_provider() == "auto"
def test_normalizes_web_search_provider(self, monkeypatch):
monkeypatch.setenv(WEB_SEARCH_PROVIDER, " Google ")
assert get_web_search_provider() == "google"
def test_brave_web_search_provider(self, monkeypatch):
monkeypatch.setenv(WEB_SEARCH_PROVIDER, "Brave")
assert get_web_search_provider() == "brave"
def test_empty_web_search_provider_means_auto(self, monkeypatch):
monkeypatch.setenv(WEB_SEARCH_PROVIDER, " ")
assert get_web_search_provider() == "auto"
def test_invalid_web_search_provider_fails_closed(self, monkeypatch, caplog):
monkeypatch.setenv(WEB_SEARCH_PROVIDER, "bing")
with caplog.at_level("ERROR"):
provider = get_web_search_provider()
assert provider not in WEB_SEARCH_PROVIDERS
assert provider != "auto"
assert WEB_SEARCH_PROVIDER in caplog.text
class TestGetBraveSearchCountry:
def test_values(self, monkeypatch):
monkeypatch.delenv("XAGENT_BRAVE_SEARCH_COUNTRY", raising=False)
assert get_brave_search_country() is None
monkeypatch.setenv("XAGENT_BRAVE_SEARCH_COUNTRY", " Au ")
assert get_brave_search_country() == "au"
monkeypatch.setenv("XAGENT_BRAVE_SEARCH_COUNTRY", "")
assert get_brave_search_country() is None
def test_invalid_value_ignored(self, monkeypatch):
monkeypatch.setenv("XAGENT_BRAVE_SEARCH_COUNTRY", "AUS")
assert get_brave_search_country() is None
class TestGetBraveSearchEndpoint:
def test_default_and_values(self, monkeypatch):
monkeypatch.delenv("XAGENT_BRAVE_SEARCH_ENDPOINT", raising=False)
assert get_brave_search_endpoint() == "web"
monkeypatch.setenv("XAGENT_BRAVE_SEARCH_ENDPOINT", " LLM_Context ")
assert get_brave_search_endpoint() == "llm_context"
def test_unknown_value_uses_web_and_warns(self, monkeypatch, caplog):
monkeypatch.setenv("XAGENT_BRAVE_SEARCH_ENDPOINT", "bogus")
with caplog.at_level("WARNING"):
assert get_brave_search_endpoint() == "web"
assert "XAGENT_BRAVE_SEARCH_ENDPOINT" in caplog.text
class TestGetWebCrawlTlsImpersonate:
"""Test get_web_crawl_tls_impersonate() function."""
def test_default_web_crawl_tls_impersonate(self, monkeypatch):
monkeypatch.delenv(WEB_CRAWL_TLS_IMPERSONATE, raising=False)
assert get_web_crawl_tls_impersonate() is None
@pytest.mark.parametrize("value", ["", " ", "none", "None", "NULL"])
def test_empty_like_web_crawl_tls_impersonate(self, monkeypatch, value):
monkeypatch.setenv(WEB_CRAWL_TLS_IMPERSONATE, value)
assert get_web_crawl_tls_impersonate() is None
def test_auto_web_crawl_tls_impersonate(self, monkeypatch):
monkeypatch.setenv(WEB_CRAWL_TLS_IMPERSONATE, " auto ")
assert get_web_crawl_tls_impersonate() == "auto"
def test_specific_web_crawl_tls_impersonate(self, monkeypatch):
monkeypatch.setenv(WEB_CRAWL_TLS_IMPERSONATE, "safari17_0")
assert get_web_crawl_tls_impersonate() == "safari17_0"
class TestGetMaxUploadSizeBytes:
"""Test get_max_upload_size_bytes() function."""
def test_default_max_upload_size(self, monkeypatch):
monkeypatch.delenv(MAX_UPLOAD_SIZE, raising=False)
assert get_max_upload_size_bytes() == 100 * 1024 * 1024
def test_numeric_max_upload_size(self, monkeypatch):
monkeypatch.setenv(MAX_UPLOAD_SIZE, "2048")
assert get_max_upload_size_bytes() == 2048
def test_numeric_float_max_upload_size(self, monkeypatch):
monkeypatch.setenv(MAX_UPLOAD_SIZE, "1.5")
assert get_max_upload_size_bytes() == 1
def test_rejects_non_positive_max_upload_size(self, monkeypatch):
monkeypatch.setenv(MAX_UPLOAD_SIZE, "0")
with pytest.raises(ValueError, match="positive"):
get_max_upload_size_bytes()
monkeypatch.setenv(MAX_UPLOAD_SIZE, "-1")
with pytest.raises(ValueError, match="positive"):
get_max_upload_size_bytes()
def test_human_readable_max_upload_size(self, monkeypatch):
monkeypatch.setenv(MAX_UPLOAD_SIZE, "150M")
assert get_max_upload_size_bytes() == 150 * 1024 * 1024
def test_invalid_max_upload_size_raises(self, monkeypatch):
monkeypatch.setenv(MAX_UPLOAD_SIZE, "banana")
with pytest.raises(ValueError, match="XAGENT_MAX_UPLOAD_SIZE"):
get_max_upload_size_bytes()
class TestFormatFileSize:
def test_formats_kilobytes(self):
assert format_file_size(512 * 1024) == "512KB"
def test_formats_fractional_megabytes(self):
assert format_file_size(1572864) == "1.5MB"
def test_promotes_boundary_values_to_next_unit(self):
assert format_file_size(1048575) == "1MB"
class TestFileStorageConfig:
def test_default_file_storage_uri_uses_storage_root(self, monkeypatch):
monkeypatch.delenv(FILE_STORAGE_URI, raising=False)
monkeypatch.setenv(STORAGE_ROOT, "/custom/storage")
assert get_file_storage_uri() == "file:///custom/storage/files"
def test_default_file_storage_uri_resolves_relative_storage_root(
self, monkeypatch, tmp_path
):
monkeypatch.delenv(FILE_STORAGE_URI, raising=False)
monkeypatch.chdir(tmp_path)
monkeypatch.setenv(STORAGE_ROOT, ".xagent")
assert get_file_storage_uri() == (tmp_path / ".xagent" / "files").as_uri()
def test_file_storage_uri_with_env_var(self, monkeypatch):
monkeypatch.setenv(FILE_STORAGE_URI, "s3://bucket/prefix")
assert get_file_storage_uri() == "s3://bucket/prefix"
def test_file_storage_options_default_to_empty_dict(self, monkeypatch):
monkeypatch.delenv(FILE_STORAGE_OPTIONS, raising=False)
assert get_file_storage_options() == {}
def test_file_storage_options_parse_json_object(self, monkeypatch):
monkeypatch.setenv(
FILE_STORAGE_OPTIONS,
'{"endpoint_url":"https://s3.example.com","region_name":"us-east-1"}',
)
assert get_file_storage_options() == {
"endpoint_url": "https://s3.example.com",
"region_name": "us-east-1",
}
def test_file_storage_options_reject_non_object_json(self, monkeypatch):
monkeypatch.setenv(FILE_STORAGE_OPTIONS, '["not", "an", "object"]')
with pytest.raises(ValueError, match="XAGENT_FILE_STORAGE_OPTIONS"):
get_file_storage_options()
def test_file_materialize_dir_default(self, monkeypatch):
monkeypatch.delenv(FILE_MATERIALIZE_DIR, raising=False)
assert get_file_materialize_dir() == Path(gettempdir()) / "xagent-materialized"
def test_file_materialize_dir_with_env_var(self, monkeypatch):
monkeypatch.setenv(FILE_MATERIALIZE_DIR, "/custom/materialized")
assert get_file_materialize_dir() == Path("/custom/materialized")
def test_preview_tmp_dir_default(self, monkeypatch):
monkeypatch.delenv(PREVIEW_TMP_DIR, raising=False)
assert get_preview_tmp_dir() == Path(gettempdir()) / "xagent-preview"
def test_preview_tmp_dir_with_env_var(self, monkeypatch):
monkeypatch.setenv(PREVIEW_TMP_DIR, "/custom/preview-tmp")
assert get_preview_tmp_dir() == Path("/custom/preview-tmp")
def test_file_storage_startup_sync_enabled_defaults_true(self, monkeypatch):
monkeypatch.delenv(FILE_STORAGE_STARTUP_SYNC_ENABLED, raising=False)
assert get_file_storage_startup_sync_enabled() is True
@pytest.mark.parametrize(
"value,expected",
[
("true", True),
("1", True),
("yes", True),
("on", True),
("false", False),
("0", False),
("no", False),
("off", False),
],
)
def test_file_storage_startup_sync_enabled_parses_bool(
self, monkeypatch, value, expected
):
monkeypatch.setenv(FILE_STORAGE_STARTUP_SYNC_ENABLED, value)
assert get_file_storage_startup_sync_enabled() is expected
def test_file_storage_startup_sync_enabled_rejects_invalid(self, monkeypatch):
monkeypatch.setenv(FILE_STORAGE_STARTUP_SYNC_ENABLED, "maybe")
with pytest.raises(
ValueError, match="XAGENT_FILE_STORAGE_STARTUP_SYNC_ENABLED"
):
get_file_storage_startup_sync_enabled()
def test_file_delivery_redirect_enabled_defaults_false(self, monkeypatch):
monkeypatch.delenv(FILE_DELIVERY_REDIRECT_ENABLED, raising=False)
assert get_file_delivery_redirect_enabled() is False
@pytest.mark.parametrize(
"value,expected",
[
("true", True),
("1", True),
("yes", True),
("on", True),
("false", False),
("0", False),
("no", False),
("off", False),
],
)
def test_file_delivery_redirect_enabled_parses_bool(
self, monkeypatch, value, expected
):
monkeypatch.setenv(FILE_DELIVERY_REDIRECT_ENABLED, value)
assert get_file_delivery_redirect_enabled() is expected
def test_file_delivery_redirect_enabled_rejects_invalid(self, monkeypatch):
monkeypatch.setenv(FILE_DELIVERY_REDIRECT_ENABLED, "maybe")
with pytest.raises(ValueError, match="XAGENT_FILE_DELIVERY_REDIRECT_ENABLED"):
get_file_delivery_redirect_enabled()
def test_file_delivery_signed_url_ttl_defaults_to_300(self, monkeypatch):
monkeypatch.delenv(FILE_DELIVERY_SIGNED_URL_TTL_SECONDS, raising=False)
assert get_file_delivery_signed_url_ttl_seconds() == 300
def test_file_delivery_signed_url_ttl_with_env_var(self, monkeypatch):
monkeypatch.setenv(FILE_DELIVERY_SIGNED_URL_TTL_SECONDS, "60")
assert get_file_delivery_signed_url_ttl_seconds() == 60
@pytest.mark.parametrize("value", ["0", "-1", "abc"])
def test_file_delivery_signed_url_ttl_rejects_invalid(self, monkeypatch, value):
monkeypatch.setenv(FILE_DELIVERY_SIGNED_URL_TTL_SECONDS, value)
with pytest.raises(
ValueError, match="XAGENT_FILE_DELIVERY_SIGNED_URL_TTL_SECONDS"
):
get_file_delivery_signed_url_ttl_seconds()
def test_file_stream_ticket_ttl_defaults_to_600(self, monkeypatch):
monkeypatch.delenv(FILE_STREAM_TICKET_TTL_SECONDS, raising=False)
assert get_file_stream_ticket_ttl_seconds() == 600
def test_file_stream_ticket_ttl_with_env_var(self, monkeypatch):
monkeypatch.setenv(FILE_STREAM_TICKET_TTL_SECONDS, "120")
assert get_file_stream_ticket_ttl_seconds() == 120
@pytest.mark.parametrize("value", ["0", "-1", "abc"])
def test_file_stream_ticket_ttl_rejects_invalid(self, monkeypatch, value):
monkeypatch.setenv(FILE_STREAM_TICKET_TTL_SECONDS, value)
with pytest.raises(ValueError, match="XAGENT_FILE_STREAM_TICKET_TTL_SECONDS"):
get_file_stream_ticket_ttl_seconds()
def test_external_media_url_ttl_defaults_to_600(self, monkeypatch):
monkeypatch.delenv(EXTERNAL_MEDIA_URL_TTL_SECONDS, raising=False)
assert config.get_external_media_url_ttl_seconds() == 600
def test_external_media_url_ttl_with_env_var(self, monkeypatch):
monkeypatch.setenv(EXTERNAL_MEDIA_URL_TTL_SECONDS, "900")
assert config.get_external_media_url_ttl_seconds() == 900
@pytest.mark.parametrize("value", ["0", "59", "3601", "abc"])
def test_external_media_url_ttl_rejects_invalid(self, monkeypatch, value):
monkeypatch.setenv(EXTERNAL_MEDIA_URL_TTL_SECONDS, value)
with pytest.raises(ValueError, match="XAGENT_EXTERNAL_MEDIA_URL_TTL_SECONDS"):
config.get_external_media_url_ttl_seconds()
def test_file_delivery_accel_redirect_enabled_defaults_false(self, monkeypatch):
monkeypatch.delenv(FILE_DELIVERY_ACCEL_REDIRECT_ENABLED, raising=False)
assert get_file_delivery_accel_redirect_enabled() is False
@pytest.mark.parametrize(
"value,expected",
[
("true", True),
("1", True),
("yes", True),
("on", True),
("false", False),
("0", False),
("no", False),
("off", False),
],
)
def test_file_delivery_accel_redirect_enabled_parses_bool(
self, monkeypatch, value, expected
):
monkeypatch.setenv(FILE_DELIVERY_ACCEL_REDIRECT_ENABLED, value)
assert get_file_delivery_accel_redirect_enabled() is expected
def test_file_delivery_accel_redirect_enabled_rejects_invalid(self, monkeypatch):
monkeypatch.setenv(FILE_DELIVERY_ACCEL_REDIRECT_ENABLED, "maybe")
with pytest.raises(
ValueError, match="XAGENT_FILE_DELIVERY_ACCEL_REDIRECT_ENABLED"
):
get_file_delivery_accel_redirect_enabled()
def test_file_delivery_accel_redirect_prefix_defaults_to_internal_uri(
self, monkeypatch
):
monkeypatch.delenv(FILE_DELIVERY_ACCEL_REDIRECT_PREFIX, raising=False)
assert get_file_delivery_accel_redirect_prefix() == "/_xagent_internal_files/"
def test_file_delivery_accel_redirect_prefix_normalizes_trailing_slash(
self, monkeypatch
):
monkeypatch.setenv(FILE_DELIVERY_ACCEL_REDIRECT_PREFIX, "/private-files")
assert get_file_delivery_accel_redirect_prefix() == "/private-files/"
def test_file_delivery_accel_redirect_prefix_requires_absolute_uri(
self, monkeypatch
):
monkeypatch.setenv(FILE_DELIVERY_ACCEL_REDIRECT_PREFIX, "private-files")
with pytest.raises(
ValueError, match="XAGENT_FILE_DELIVERY_ACCEL_REDIRECT_PREFIX"
):
get_file_delivery_accel_redirect_prefix()
class TestGetUploadsDir:
"""Test get_uploads_dir() function."""
def test_default_uploads_dir(self, monkeypatch):
"""Test default uploads directory path."""
monkeypatch.delenv(UPLOADS_DIR, raising=False)
monkeypatch.delenv(WEB_DIR, raising=False)
result = get_uploads_dir()
# Default is src/xagent/web/uploads
assert result.name == "uploads"
assert result.parent.name == "web"
def test_uploads_dir_with_env_var(self, monkeypatch):
"""Test uploads directory with environment variable."""
monkeypatch.setenv(UPLOADS_DIR, "/tmp/test_uploads")
result = get_uploads_dir()
assert result == Path("/tmp/test_uploads")
def test_uploads_dir_env_overrides_web_dir(self, monkeypatch):
"""Test that UPLOADS_DIR env var overrides computed default."""
monkeypatch.setenv(WEB_DIR, "/custom/web")
monkeypatch.setenv(UPLOADS_DIR, "/custom/uploads")
result = get_uploads_dir()
assert result == Path("/custom/uploads")
class TestGetWebDir:
"""Test get_web_dir() function."""
def test_default_web_dir(self, monkeypatch):
"""Test default web directory path."""
monkeypatch.delenv(WEB_DIR, raising=False)
result = get_web_dir()
assert result.name == "web"
def test_web_dir_with_env_var(self, monkeypatch):
"""Test web directory with environment variable."""
monkeypatch.setenv(WEB_DIR, "/custom/web")
result = get_web_dir()
assert result == Path("/custom/web")
@pytest.mark.parametrize(
"value, expected",
[
(None, ""),
("", ""),
(" auto ", "auto"),
(" https://preview.example.test/path ", "https://preview.example.test/path"),
],
)
def test_get_html_preview_origin(monkeypatch, value, expected):
monkeypatch.delenv(config.HTML_PREVIEW_ORIGIN, raising=False)
if value is not None:
monkeypatch.setenv(config.HTML_PREVIEW_ORIGIN, value)
assert config.get_html_preview_origin() == expected
class TestGetFrontendDistDir:
"""Test get_frontend_dist_dir() function."""
def test_default_frontend_dist_dir(self, monkeypatch):
"""Defaults to WEB_DIR/frontend_dist."""
monkeypatch.delenv(FRONTEND_DIST_DIR, raising=False)
monkeypatch.delenv(WEB_DIR, raising=False)
result = get_frontend_dist_dir()
assert result.name == "frontend_dist"
assert result.parent.name == "web"
def test_frontend_dist_dir_with_env_var(self, monkeypatch):
"""Environment variable overrides the default."""
monkeypatch.setenv(FRONTEND_DIST_DIR, "/custom/dist")
result = get_frontend_dist_dir()
assert result == Path("/custom/dist")
def test_frontend_dist_dir_follows_web_dir_default(self, monkeypatch):
"""Default is computed under the configured WEB_DIR."""
monkeypatch.delenv(FRONTEND_DIST_DIR, raising=False)
monkeypatch.setenv(WEB_DIR, "/custom/web")
result = get_frontend_dist_dir()
assert result == Path("/custom/web/frontend_dist")
class TestGetAgentRuntime:
"""Test get_agent_runtime() function."""
def test_default_agent_runtime(self, monkeypatch):
monkeypatch.delenv(AGENT_RUNTIME, raising=False)
assert get_agent_runtime() == "v1"
def test_agent_runtime_v2(self, monkeypatch):
monkeypatch.setenv(AGENT_RUNTIME, "v2")
assert get_agent_runtime() == "v2"
def test_agent_runtime_normalizes_case_and_spaces(self, monkeypatch):
monkeypatch.setenv(AGENT_RUNTIME, " V2 ")
assert get_agent_runtime() == "v2"
def test_invalid_agent_runtime_falls_back_to_v1(self, monkeypatch):
monkeypatch.setenv(AGENT_RUNTIME, "unknown")
assert get_agent_runtime() == "v1"
class TestGetAgentPatternForExecutionMode:
"""Test get_agent_pattern_for_execution_mode() function."""
def test_known_execution_modes(self):
assert get_agent_pattern_for_execution_mode("flash") == "single_call"
assert get_agent_pattern_for_execution_mode("balanced") == "react"
assert get_agent_pattern_for_execution_mode("think") == "dag_plan_execute"
assert get_agent_pattern_for_execution_mode("auto") == "auto"
def test_normalizes_mode(self):
assert get_agent_pattern_for_execution_mode(" AUTO ") == "auto"
def test_unknown_mode_falls_back_to_react(self):
assert get_agent_pattern_for_execution_mode("unknown") == "react"
assert get_agent_pattern_for_execution_mode(None) == "react"
class TestGetDefaultTaskExecutionMode:
"""Test default task execution mode selection."""
def test_default_standalone_defaults_to_auto(self, monkeypatch):
monkeypatch.delenv(AGENT_RUNTIME, raising=False)
assert get_default_task_execution_mode() == "auto"
def test_v1_standalone_defaults_to_think(self, monkeypatch):
monkeypatch.setenv(AGENT_RUNTIME, "v1")
assert get_default_task_execution_mode() == "think"
def test_v2_standalone_defaults_to_auto(self, monkeypatch):
monkeypatch.setenv(AGENT_RUNTIME, "v2")
assert get_default_task_execution_mode() == "auto"
def test_agent_tasks_default_to_balanced_in_v2(self, monkeypatch):
monkeypatch.setenv(AGENT_RUNTIME, "v2")
assert get_default_task_execution_mode(agent_id=123) == "balanced"
def test_explicit_runtime_can_be_passed(self):
assert get_default_task_execution_mode(agent_runtime="v2") == "auto"
class TestGetExternalUploadDirs:
"""Test get_external_upload_dirs() function."""
def test_no_env_var_returns_empty_list(self, monkeypatch):
"""Test that missing env var returns empty list."""
monkeypatch.delenv(EXTERNAL_UPLOAD_DIRS, raising=False)
result = get_external_upload_dirs()
assert result == []
def test_empty_env_var_returns_empty_list(self, monkeypatch):
"""Test that empty env var returns empty list."""
monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, "")
result = get_external_upload_dirs()
assert result == []
def test_nonexistent_dirs_are_filtered(self, monkeypatch):
"""Test that nonexistent directories are not included."""
monkeypatch.setenv(
EXTERNAL_UPLOAD_DIRS, "/nonexistent/path1,/nonexistent/path2"
)
result = get_external_upload_dirs()
assert result == []
def test_existing_dirs_are_included(self, monkeypatch):
"""Test that existing directories are included."""
with tempfile.TemporaryDirectory() as tmpdir:
dir1 = Path(tmpdir) / "uploads1"
dir2 = Path(tmpdir) / "uploads2"
dir1.mkdir()
dir2.mkdir()
monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, f"{dir1},{dir2}")
result = get_external_upload_dirs()
assert len(result) == 2
assert dir1 in result
assert dir2 in result
def test_expands_environment_tilde_and_preserves_symlink_spelling(
self, tmp_path, monkeypatch
):
physical = tmp_path / "physical" / "uploads"
physical.mkdir(parents=True)
alias = tmp_path / "alias"
alias.symlink_to(physical, target_is_directory=True)
monkeypatch.setenv("HOME", str(tmp_path))
monkeypatch.setenv("EXTERNAL_NAME", "alias")
monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, "~/$EXTERNAL_NAME")
assert get_external_upload_dirs() == [alias]
def test_rejects_symlink_followed_by_dotdot(self, tmp_path, monkeypatch):
base = tmp_path / "base"
outside = tmp_path / "outside" / "nested"
base.mkdir()
outside.mkdir(parents=True)
(base / "link").symlink_to(outside, target_is_directory=True)
monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, str(base / "link" / ".."))
with pytest.raises(ExternalUploadsDirConfigurationError, match="two different"):
get_external_upload_dirs()
def test_relative_dir_is_pinned_to_first_working_directory(
self, tmp_path, monkeypatch
):
first_cwd = tmp_path / "first"
second_cwd = tmp_path / "second"
external = first_cwd / "relative-external"
external.mkdir(parents=True)
second_cwd.mkdir()
relative_spelling = "relative-external"
monkeypatch.setenv(EXTERNAL_UPLOAD_DIRS, relative_spelling)
monkeypatch.chdir(first_cwd)
assert get_external_upload_dirs() == [external]
monkeypatch.chdir(second_cwd)
assert get_external_upload_dirs() == [external]
class TestGetExternalSkillsDirs:
"""Test get_external_skills_dirs() function."""
def test_no_env_var_returns_empty_list(self, monkeypatch):
"""Test that missing env var returns empty list."""
monkeypatch.delenv(EXTERNAL_SKILLS_LIBRARY_DIRS, raising=False)
result = get_external_skills_dirs()
assert result == []
def test_tilde_expansion(self, monkeypatch):
"""Test that tilde (~) is expanded to home directory."""
monkeypatch.setenv(EXTERNAL_SKILLS_LIBRARY_DIRS, "~/skills")
result = get_external_skills_dirs()
assert len(result) == 1
assert result[0] == Path.home() / "skills"
def test_env_var_expansion(self, monkeypatch):
"""Test that environment variables in paths are expanded."""
monkeypatch.setenv("CUSTOM_SKILLS_DIR", "/opt/skills")
monkeypatch.setenv(EXTERNAL_SKILLS_LIBRARY_DIRS, "$CUSTOM_SKILLS_DIR")
result = get_external_skills_dirs()
assert len(result) == 1
assert result[0] == Path("/opt/skills")
def test_url_like_paths_are_skipped(self, monkeypatch):
"""Test that URL-like paths are skipped with warning."""
monkeypatch.setenv(EXTERNAL_SKILLS_LIBRARY_DIRS, "https://example.com/skills")
result = get_external_skills_dirs()
assert result == []
class TestGetStorageRoot:
"""Test get_storage_root() function."""
def test_default_storage_root(self, monkeypatch):
"""Test default storage root path."""
monkeypatch.delenv(STORAGE_ROOT, raising=False)
result = get_storage_root()
assert result == Path.home() / ".xagent"
def test_storage_root_with_env_var(self, monkeypatch):
"""Test storage root with environment variable."""
monkeypatch.setenv(STORAGE_ROOT, "/custom/storage")
result = get_storage_root()
assert result == Path("/custom/storage")
def test_storage_root_expands_tilde(self, monkeypatch, tmp_path):
"""A ~-prefixed env value resolves to the home directory."""
monkeypatch.setenv("HOME", str(tmp_path))
monkeypatch.setenv(STORAGE_ROOT, "~/custom-root")
result = get_storage_root()
assert result == tmp_path / "custom-root"
class TestGetSandboxImage:
"""Test get_sandbox_image() function."""
def test_default_sandbox_image(self, monkeypatch):
"""Test default sandbox image name."""
monkeypatch.delenv(SANDBOX_IMAGE, raising=False)
result = get_sandbox_image()
assert result == "xprobe/xagent-sandbox:latest"
def test_sandbox_image_with_env_var(self, monkeypatch):
"""Test sandbox image with environment variable."""
monkeypatch.setenv(SANDBOX_IMAGE, "custom/sandbox:v1.0")
result = get_sandbox_image()
assert result == "custom/sandbox:v1.0"
class TestGetLancedbPath:
"""Test get_lancedb_path() function."""
def test_default_lancedb_path(self, monkeypatch):
"""Test default LanceDB path (relative to storage root)."""
monkeypatch.delenv(LANCEDB_PATH, raising=False)
monkeypatch.delenv(STORAGE_ROOT, raising=False)
result = get_lancedb_path()
assert result == Path.home() / ".xagent" / "data" / "lancedb"
def test_lancedb_path_with_env_var(self, monkeypatch):
"""Test LanceDB path with environment variable."""
monkeypatch.setenv(LANCEDB_PATH, "/custom/lancedb")
result = get_lancedb_path()
assert result == Path("/custom/lancedb")
class TestGoogleDriveDownloadTimeout:
"""Test the Google Drive LRO timeout configuration."""
def test_constant_name(self):
assert (
config.GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS
== "XAGENT_GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS"
)
def test_default(self, monkeypatch):
monkeypatch.delenv(
"XAGENT_GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS", raising=False
)
assert config.get_google_drive_download_timeout_seconds() == 600
def test_environment_override(self, monkeypatch):
monkeypatch.setenv("XAGENT_GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS", "120")
assert config.get_google_drive_download_timeout_seconds() == 120
@pytest.mark.parametrize("value", ["0", "-1", "not-a-number"])
def test_invalid_value_uses_default(self, monkeypatch, value):
monkeypatch.setenv("XAGENT_GOOGLE_DRIVE_DOWNLOAD_TIMEOUT_SECONDS", value)
assert config.get_google_drive_download_timeout_seconds() == 600
class TestGetKbCollectionsTimeoutSeconds:
"""Test get_kb_collections_timeout_seconds() function."""
def test_env_var_constant(self):
assert KB_COLLECTIONS_TIMEOUT_SECONDS == "XAGENT_KB_COLLECTIONS_TIMEOUT_SECONDS"
def test_default(self, monkeypatch):
monkeypatch.delenv(KB_COLLECTIONS_TIMEOUT_SECONDS, raising=False)
assert get_kb_collections_timeout_seconds() == 30
def test_env_override(self, monkeypatch):
monkeypatch.setenv(KB_COLLECTIONS_TIMEOUT_SECONDS, "90")
assert get_kb_collections_timeout_seconds() == 90
def test_invalid_falls_back_to_default(self, monkeypatch):
monkeypatch.setenv(KB_COLLECTIONS_TIMEOUT_SECONDS, "not-a-number")
assert get_kb_collections_timeout_seconds() == 30
def test_non_positive_falls_back_to_default(self, monkeypatch):
monkeypatch.setenv(KB_COLLECTIONS_TIMEOUT_SECONDS, "0")
assert get_kb_collections_timeout_seconds() == 30
class TestGetKbSearchTimeoutSeconds:
"""Test get_kb_search_timeout_seconds() function."""
def test_env_var_constant(self):
assert KB_SEARCH_TIMEOUT_SECONDS == "XAGENT_KB_SEARCH_TIMEOUT_SECONDS"
def test_default(self, monkeypatch):
monkeypatch.delenv(KB_SEARCH_TIMEOUT_SECONDS, raising=False)
assert get_kb_search_timeout_seconds() == 60
def test_env_override(self, monkeypatch):
monkeypatch.setenv(KB_SEARCH_TIMEOUT_SECONDS, "5")
assert get_kb_search_timeout_seconds() == 5
def test_invalid_falls_back_to_default(self, monkeypatch):
monkeypatch.setenv(KB_SEARCH_TIMEOUT_SECONDS, "not-a-number")
assert get_kb_search_timeout_seconds() == 60
def test_non_positive_falls_back_to_default(self, monkeypatch):
monkeypatch.setenv(KB_SEARCH_TIMEOUT_SECONDS, "0")
assert get_kb_search_timeout_seconds() == 60
class TestDeepDocRemoteParsingConfig:
"""Test the remote DeepDoc parsing (Xinference) configuration getters."""
def test_env_var_constants(self):
assert DEEPDOC_XINFERENCE_URL == "XAGENT_DEEPDOC_XINFERENCE_URL"
assert DEEPDOC_XINFERENCE_API_KEY == "XAGENT_DEEPDOC_XINFERENCE_API_KEY"
assert (
DEEPDOC_XINFERENCE_TIMEOUT_SECONDS
== "XAGENT_DEEPDOC_XINFERENCE_TIMEOUT_SECONDS"
)
assert DEEPDOC_XINFERENCE_MODEL_UID == "XAGENT_DEEPDOC_XINFERENCE_MODEL_UID"
assert DEEPDOC_XINFERENCE_USERNAME == "XAGENT_DEEPDOC_XINFERENCE_USERNAME"
assert DEEPDOC_XINFERENCE_PASSWORD == "XAGENT_DEEPDOC_XINFERENCE_PASSWORD"
def test_url_unset_defaults_to_local_mode(self, monkeypatch):
monkeypatch.delenv(DEEPDOC_XINFERENCE_URL, raising=False)
assert get_deepdoc_xinference_url() is None
def test_url_blank_defaults_to_local_mode(self, monkeypatch):
monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, " ")
assert get_deepdoc_xinference_url() is None
def test_url_strips_whitespace_and_trailing_slash(self, monkeypatch):
monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, " http://gpu-host:9997/ ")
assert get_deepdoc_xinference_url() == "http://gpu-host:9997"
@pytest.mark.parametrize(
"value",
[
"gpu-host:9997",
"ftp://gpu-host:9997",
"https:///missing-host",
"http://gpu-host:9997?model=deepdoc",
"http://gpu-host:9997#deepdoc",
"http://gpu-host:9997/v1/deepdoc?model=deepdoc",
],
)
def test_url_rejects_invalid_values(self, monkeypatch, value):
monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, value)
with pytest.raises(ValueError, match="XAGENT_DEEPDOC_XINFERENCE_URL"):
get_deepdoc_xinference_url()
def test_api_key_dedicated_var_wins(self, monkeypatch):
monkeypatch.setenv(DEEPDOC_XINFERENCE_API_KEY, " deepdoc-key ")
monkeypatch.setenv("XINFERENCE_API_KEY", "shared-key")
assert get_deepdoc_xinference_api_key() == "deepdoc-key"
def test_api_key_falls_back_to_shared_xinference_key(self, monkeypatch):
monkeypatch.delenv(DEEPDOC_XINFERENCE_API_KEY, raising=False)
monkeypatch.setenv("XINFERENCE_API_KEY", " shared-key ")
assert get_deepdoc_xinference_api_key() == "shared-key"
def test_api_key_blank_dedicated_var_falls_back(self, monkeypatch):
monkeypatch.setenv(DEEPDOC_XINFERENCE_API_KEY, " ")
monkeypatch.setenv("XINFERENCE_API_KEY", "shared-key")
assert get_deepdoc_xinference_api_key() == "shared-key"
def test_api_key_unset_means_no_auth(self, monkeypatch):
monkeypatch.delenv(DEEPDOC_XINFERENCE_API_KEY, raising=False)
monkeypatch.delenv("XINFERENCE_API_KEY", raising=False)
assert get_deepdoc_xinference_api_key() is None
def test_timeout_default(self, monkeypatch):
monkeypatch.delenv(DEEPDOC_XINFERENCE_TIMEOUT_SECONDS, raising=False)
assert get_deepdoc_xinference_timeout_seconds() == 1800
def test_timeout_env_override(self, monkeypatch):
monkeypatch.setenv(DEEPDOC_XINFERENCE_TIMEOUT_SECONDS, "600")
assert get_deepdoc_xinference_timeout_seconds() == 600
@pytest.mark.parametrize("value", ["not-a-number", "", "0", "-1"])
def test_timeout_invalid_or_non_positive_falls_back(self, monkeypatch, value):
monkeypatch.setenv(DEEPDOC_XINFERENCE_TIMEOUT_SECONDS, value)
assert get_deepdoc_xinference_timeout_seconds() == 1800
def test_model_uid_defaults_to_the_family_name(self, monkeypatch):
monkeypatch.delenv(DEEPDOC_XINFERENCE_MODEL_UID, raising=False)
assert get_deepdoc_xinference_model_uid() == "DeepDoc"
def test_model_uid_env_override_is_trimmed(self, monkeypatch):
monkeypatch.setenv(DEEPDOC_XINFERENCE_MODEL_UID, " deepdoc-gpu-1 ")
assert get_deepdoc_xinference_model_uid() == "deepdoc-gpu-1"
@pytest.mark.parametrize("value", ["", " "])
def test_model_uid_blank_falls_back_to_the_default(self, monkeypatch, value):
monkeypatch.setenv(DEEPDOC_XINFERENCE_MODEL_UID, value)
assert get_deepdoc_xinference_model_uid() == "DeepDoc"
def test_username_unset_means_no_token_exchange(self, monkeypatch):
monkeypatch.delenv(DEEPDOC_XINFERENCE_USERNAME, raising=False)
assert get_deepdoc_xinference_username() is None
def test_username_is_trimmed(self, monkeypatch):
monkeypatch.setenv(DEEPDOC_XINFERENCE_USERNAME, " admin ")
assert get_deepdoc_xinference_username() == "admin"
@pytest.mark.parametrize("value", ["", " "])
def test_username_blank_means_no_token_exchange(self, monkeypatch, value):
monkeypatch.setenv(DEEPDOC_XINFERENCE_USERNAME, value)
assert get_deepdoc_xinference_username() is None
def test_password_unset_means_no_token_exchange(self, monkeypatch):
monkeypatch.delenv(DEEPDOC_XINFERENCE_PASSWORD, raising=False)
assert get_deepdoc_xinference_password() is None
def test_password_blank_means_no_token_exchange(self, monkeypatch):
monkeypatch.setenv(DEEPDOC_XINFERENCE_PASSWORD, "")
assert get_deepdoc_xinference_password() is None
def test_password_preserves_surrounding_whitespace(self, monkeypatch):
"""Whitespace can be significant in a secret, so it is not stripped."""
monkeypatch.setenv(DEEPDOC_XINFERENCE_PASSWORD, " pa ss ")
assert get_deepdoc_xinference_password() == " pa ss "
class TestGetDefaultSqliteDbPath:
"""Test get_default_sqlite_db_path() function."""
def test_default_sqlite_db_path(self, monkeypatch):
"""Test default SQLite database path."""
monkeypatch.delenv(STORAGE_ROOT, raising=False)
result = get_default_sqlite_db_path()
assert result == str(Path.home() / ".xagent" / "xagent.db")
def test_sqlite_db_path_respects_storage_root(self, monkeypatch):
"""Test that SQLite path respects STORAGE_ROOT env var."""
monkeypatch.setenv(STORAGE_ROOT, "/custom/storage")
result = get_default_sqlite_db_path()
assert result == "/custom/storage/xagent.db"
class TestGetDatabaseUrl:
"""Test get_database_url() function."""
def test_default_database_url(self, monkeypatch):
"""Test default database URL (SQLite)."""
monkeypatch.delenv(DATABASE_URL, raising=False)
monkeypatch.delenv(STORAGE_ROOT, raising=False)
result = get_database_url()
assert result.startswith("sqlite:///")
assert result.endswith("xagent.db")
def test_database_url_with_env_var(self, monkeypatch):
"""Test database URL with environment variable."""
monkeypatch.setenv(DATABASE_URL, "postgresql://user:pass@localhost/db")
result = get_database_url()
assert result == "postgresql://user:pass@localhost/db"
class TestDbPoolConfig:
"""Test DB pool sizing getters."""
def test_defaults(self, monkeypatch):
monkeypatch.delenv(DB_POOL_SIZE, raising=False)
monkeypatch.delenv(DB_MAX_OVERFLOW, raising=False)
monkeypatch.delenv(DB_POOL_TIMEOUT_SECONDS, raising=False)
assert get_db_pool_size() == 10
assert get_db_max_overflow() == 20
assert get_db_pool_timeout_seconds() == 30
def test_env_overrides(self, monkeypatch):
monkeypatch.setenv(DB_POOL_SIZE, "25")
monkeypatch.setenv(DB_MAX_OVERFLOW, "0")
monkeypatch.setenv(DB_POOL_TIMEOUT_SECONDS, "5")
assert get_db_pool_size() == 25
assert get_db_max_overflow() == 0
assert get_db_pool_timeout_seconds() == 5
def test_invalid_values_fall_back(self, monkeypatch):
monkeypatch.setenv(DB_POOL_SIZE, "abc")
monkeypatch.setenv(DB_MAX_OVERFLOW, "-1")
monkeypatch.setenv(DB_POOL_TIMEOUT_SECONDS, "0")
assert get_db_pool_size() == 10
assert get_db_max_overflow() == 20
assert get_db_pool_timeout_seconds() == 30
class TestMcpToolInitTimeout:
"""Test get_mcp_tool_init_timeout_seconds() function."""
def test_default(self, monkeypatch):
monkeypatch.delenv(MCP_TOOL_INIT_TIMEOUT_SECONDS, raising=False)
assert get_mcp_tool_init_timeout_seconds() == 60
def test_env_override(self, monkeypatch):
monkeypatch.setenv(MCP_TOOL_INIT_TIMEOUT_SECONDS, "120")
assert get_mcp_tool_init_timeout_seconds() == 120
def test_zero_disables(self, monkeypatch):
monkeypatch.setenv(MCP_TOOL_INIT_TIMEOUT_SECONDS, "0")
assert get_mcp_tool_init_timeout_seconds() == 0
def test_invalid_falls_back(self, monkeypatch):
monkeypatch.setenv(MCP_TOOL_INIT_TIMEOUT_SECONDS, "not-a-number")
assert get_mcp_tool_init_timeout_seconds() == 60
class TestGetSandboxCpus:
"""Test get_sandbox_cpus() function."""
def test_no_env_var_returns_none(self, monkeypatch):
"""Test that missing env var returns None."""
monkeypatch.delenv(SANDBOX_CPUS, raising=False)
result = get_sandbox_cpus()
assert result is None
def test_valid_cpu_count(self, monkeypatch):
"""Test valid CPU count from env var."""
monkeypatch.setenv(SANDBOX_CPUS, "4")
result = get_sandbox_cpus()
assert result == 4
def test_invalid_cpu_count_returns_none(self, monkeypatch):
"""Test that invalid CPU count returns None."""
monkeypatch.setenv(SANDBOX_CPUS, "invalid")
result = get_sandbox_cpus()
assert result is None
class TestGetSandboxMemory:
"""Test get_sandbox_memory() function."""
def test_no_env_var_returns_none(self, monkeypatch):
"""Test that missing env var returns None."""
monkeypatch.delenv(SANDBOX_MEMORY, raising=False)
result = get_sandbox_memory()
assert result is None
def test_valid_memory_value(self, monkeypatch):
"""Test valid memory value from env var."""
monkeypatch.setenv(SANDBOX_MEMORY, "2048")
result = get_sandbox_memory()
assert result == 2048
def test_invalid_memory_value_returns_none(self, monkeypatch):
"""Test that invalid memory value returns None."""
monkeypatch.setenv(SANDBOX_MEMORY, "invalid")
result = get_sandbox_memory()
assert result is None
class TestGetSandboxPidsLimit:
def test_default_and_override(self, monkeypatch):
from xagent.config import SANDBOX_PIDS_LIMIT, get_sandbox_pids_limit
monkeypatch.delenv(SANDBOX_PIDS_LIMIT, raising=False)
assert get_sandbox_pids_limit() == 1024
monkeypatch.setenv(SANDBOX_PIDS_LIMIT, "2048")
assert get_sandbox_pids_limit() == 2048
@pytest.mark.parametrize("value", ["invalid", "-1", "63"])
def test_invalid_or_too_small_value_uses_default(self, monkeypatch, value):
from xagent.config import SANDBOX_PIDS_LIMIT, get_sandbox_pids_limit
monkeypatch.setenv(SANDBOX_PIDS_LIMIT, value)
assert get_sandbox_pids_limit() == 1024
def test_zero_disables_limit(self, monkeypatch):
from xagent.config import SANDBOX_PIDS_LIMIT, get_sandbox_pids_limit
monkeypatch.setenv(SANDBOX_PIDS_LIMIT, "0")
assert get_sandbox_pids_limit() is None
class TestGetSandboxEnv:
"""Test get_sandbox_env() function."""
def test_no_env_var_returns_empty_dict(self, monkeypatch):
"""Test that missing env var returns empty dict."""
monkeypatch.delenv(SANDBOX_ENV, raising=False)
result = get_sandbox_env()
assert result == {}
def test_empty_env_var_returns_empty_dict(self, monkeypatch):
"""Test that empty env var returns empty dict."""
monkeypatch.setenv(SANDBOX_ENV, "")
result = get_sandbox_env()
assert result == {}
def test_valid_env_config(self, monkeypatch):
"""Test valid environment variable configuration."""
monkeypatch.setenv(SANDBOX_ENV, "KEY1=value1;KEY2=value2")
result = get_sandbox_env()
assert result == {"KEY1": "value1", "KEY2": "value2"}
def test_env_config_with_spaces(self, monkeypatch):
"""Test that spaces around keys/values are trimmed."""
monkeypatch.setenv(SANDBOX_ENV, " KEY1 = value1 ; KEY2 = value2 ")
result = get_sandbox_env()
assert result == {"KEY1": "value1", "KEY2": "value2"}
class TestGetSandboxVolumes:
"""Test get_sandbox_volumes() function."""
def test_no_env_var_returns_empty_list(self, monkeypatch):
"""Test that missing env var returns empty list."""
monkeypatch.delenv(SANDBOX_VOLUMES, raising=False)
result = get_sandbox_volumes()
assert result == []
def test_empty_env_var_returns_empty_list(self, monkeypatch):
"""Test that empty env var returns empty list."""
monkeypatch.setenv(SANDBOX_VOLUMES, "")
result = get_sandbox_volumes()
assert result == []
def test_valid_volume_config(self, monkeypatch):
"""Test valid volume configuration."""
monkeypatch.setenv(SANDBOX_VOLUMES, "/host:/container:ro")
result = get_sandbox_volumes()
assert len(result) == 1
assert result[0] == ("/host", "/container", "ro")
def test_volume_with_explicit_mode(self, monkeypatch):
"""Test volume configuration with explicit mode."""
monkeypatch.setenv(SANDBOX_VOLUMES, "/host:/container:rw")
result = get_sandbox_volumes()
assert result[0][2] == "rw"
def test_volume_defaults_to_readonly(self, monkeypatch):
"""Test that volume defaults to readonly mode."""
monkeypatch.setenv(SANDBOX_VOLUMES, "/host:/container")
result = get_sandbox_volumes()
assert result[0][2] == "ro"
def test_invalid_mode_defaults_to_readonly(self, monkeypatch):
"""Test that invalid mode defaults to readonly."""
monkeypatch.setenv(SANDBOX_VOLUMES, "/host:/container:invalid")
result = get_sandbox_volumes()
assert result[0][2] == "ro"
def test_tilde_expansion_in_volume_src(self, monkeypatch):
"""Test that tilde is expanded in volume source path."""
monkeypatch.setenv(SANDBOX_VOLUMES, "~/data:/container:ro")
result = get_sandbox_volumes()
assert result[0][0] == str(Path.home() / "data")
def test_multiple_volumes(self, monkeypatch):
"""Test multiple volume configurations."""
monkeypatch.setenv(
SANDBOX_VOLUMES, "/host1:/container1:ro;/host2:/container2:rw"
)
result = get_sandbox_volumes()
assert len(result) == 2
assert result[0] == ("/host1", "/container1", "ro")
assert result[1] == ("/host2", "/container2", "rw")
def test_host_side_sources_preserve_absolute_paths(self, monkeypatch):
"""Docker sibling volume sources are already host paths."""
monkeypatch.setenv(SANDBOX_VOLUMES, "/host/data:/container:rw")
result = get_sandbox_volumes(host_side_sources=True)
assert result == [("/host/data", "/container", "rw")]
def test_host_side_sources_reject_relative_paths(self, monkeypatch):
"""Docker sibling mode should not absolutize relative paths in backend."""
monkeypatch.setenv(SANDBOX_VOLUMES, "relative/path:/container:ro")
result = get_sandbox_volumes(host_side_sources=True)
assert result == []
def test_host_side_sources_reject_tilde_paths(self, monkeypatch):
"""Docker sibling mode should not expand backend-container home paths."""
monkeypatch.setenv(SANDBOX_VOLUMES, "~/data:/container:ro")
result = get_sandbox_volumes(host_side_sources=True)
assert result == []
class TestGetSandboxHostProjectRoot:
"""Test get_sandbox_host_project_root() function."""
def test_no_env_var_returns_none(self, monkeypatch):
"""Test that missing env var returns None."""
monkeypatch.delenv(SANDBOX_HOST_PROJECT_ROOT, raising=False)
result = get_sandbox_host_project_root()
assert result is None
def test_project_root_with_env_var(self, monkeypatch):
"""Test project root with environment variable."""
monkeypatch.setenv(SANDBOX_HOST_PROJECT_ROOT, "/host/xagent")
result = get_sandbox_host_project_root()
assert result == Path("/host/xagent")
def test_project_root_expands_env_vars_without_user_or_abspath(self, monkeypatch):
"""Host paths should not be resolved against the backend container."""
monkeypatch.setenv("HOST_PROJECT_ROOT", "/host/xagent")
monkeypatch.setenv(SANDBOX_HOST_PROJECT_ROOT, "$HOST_PROJECT_ROOT/../xagent")
result = get_sandbox_host_project_root()
assert result == Path("/host/xagent/../xagent")
class TestGetSandboxHostStorageRoot:
"""Test get_sandbox_host_storage_root() function."""
def test_no_env_var_returns_none(self, monkeypatch):
"""Test that missing env var returns None."""
monkeypatch.delenv(SANDBOX_HOST_STORAGE_ROOT, raising=False)
result = get_sandbox_host_storage_root()
assert result is None
def test_storage_root_with_env_var(self, monkeypatch):
"""Test storage root with environment variable."""
monkeypatch.setenv(SANDBOX_HOST_STORAGE_ROOT, "/host/.xagent")
result = get_sandbox_host_storage_root()
assert result == Path("/host/.xagent")
def test_storage_root_expands_env_vars_without_user_or_abspath(self, monkeypatch):
"""Host paths should not be resolved against the backend container."""
monkeypatch.setenv("HOST_STORAGE_ROOT", "/host/.xagent")
monkeypatch.setenv(SANDBOX_HOST_STORAGE_ROOT, "$HOST_STORAGE_ROOT/../.xagent")
result = get_sandbox_host_storage_root()
assert result == Path("/host/.xagent/../.xagent")
class TestGetSandboxNamespace:
"""Test get_sandbox_namespace() function."""
def test_no_env_var_returns_none(self, monkeypatch):
"""Test that a missing namespace returns None."""
monkeypatch.delenv(SANDBOX_NAMESPACE, raising=False)
result = get_sandbox_namespace()
assert result is None
def test_blank_env_var_returns_none(self, monkeypatch):
"""Test that a blank namespace returns None."""
monkeypatch.setenv(SANDBOX_NAMESPACE, " ")
result = get_sandbox_namespace()
assert result is None
def test_valid_namespace(self, monkeypatch):
"""Test that a Compose-project-name-shaped namespace is accepted."""
monkeypatch.setenv(SANDBOX_NAMESPACE, "my-project-1")
result = get_sandbox_namespace()
assert result == "my-project-1"
@pytest.mark.parametrize(
"value",
[
"Upper-Case",
"-leading-dash",
"has space",
":",
"a::b",
"a/b",
"a.b",
"café",
],
)
def test_invalid_namespace_raises(self, monkeypatch, value):
"""Test that malformed namespaces raise instead of silently degrading."""
monkeypatch.setenv(SANDBOX_NAMESPACE, value)
with pytest.raises(ValueError, match="Invalid sandbox namespace"):
get_sandbox_namespace()
def test_validation_helper_rejects_empty_namespace(self):
"""Direct callers must not bypass the getter's blank-to-None policy."""
with pytest.raises(ValueError, match="Invalid sandbox namespace"):
validate_sandbox_namespace("")
def test_long_namespace_accepted_like_compose(self, monkeypatch):
"""Compose accepts arbitrary-length project names; so must we.
Container identities hash the full namespace, label values preserve
it, and snapshot repository names use a bounded sanitized token plus
a digest, so backend identifiers do not impose a namespace length cap.
"""
monkeypatch.setenv(SANDBOX_NAMESPACE, "a" * 100)
assert get_sandbox_namespace() == "a" * 100
class TestGetSandboxNetwork:
def test_missing_or_blank_returns_none(self, monkeypatch):
monkeypatch.delenv(SANDBOX_NETWORK, raising=False)
assert get_sandbox_network() is None
monkeypatch.setenv(SANDBOX_NETWORK, " ")
assert get_sandbox_network() is None
def test_dedicated_network_name_is_accepted(self, monkeypatch):
monkeypatch.setenv(SANDBOX_NETWORK, "stage_sandbox-egress.v1")
assert get_sandbox_network() == "stage_sandbox-egress.v1"
@pytest.mark.parametrize(
"value",
["bridge", "host", "none", "default", "has space", "/bad", "a" * 256],
)
def test_builtin_or_malformed_network_is_rejected(self, monkeypatch, value):
monkeypatch.setenv(SANDBOX_NETWORK, value)
with pytest.raises(ValueError, match="Invalid sandbox network"):
get_sandbox_network()
def test_direct_validation_is_fail_closed(self):
with pytest.raises(ValueError, match="Invalid sandbox network"):
validate_sandbox_network("")
class TestSandboxWorkspaceMountConfig:
def test_mount_mode_defaults_to_bind(self, monkeypatch):
monkeypatch.delenv(SANDBOX_WORKSPACE_MOUNT_MODE, raising=False)
assert get_sandbox_workspace_mount_mode() == "bind"
def test_volume_subpath_mode_and_settings(self, monkeypatch):
monkeypatch.setenv(SANDBOX_WORKSPACE_MOUNT_MODE, "volume_subpath")
monkeypatch.setenv(SANDBOX_WORKSPACE_VOLUME, "xagent-stage-workspaces")
monkeypatch.setenv(SANDBOX_WORKSPACE_VOLUME_ROOT, "/root/.xagent/uploads")
assert get_sandbox_workspace_mount_mode() == "volume_subpath"
assert get_sandbox_workspace_volume() == "xagent-stage-workspaces"
assert get_sandbox_workspace_volume_root() == Path("/root/.xagent/uploads")
@pytest.mark.parametrize("value", ["", "volume", "host", "named-volume"])
def test_invalid_mount_mode_is_rejected(self, monkeypatch, value):
monkeypatch.setenv(SANDBOX_WORKSPACE_MOUNT_MODE, value)
if value == "":
assert get_sandbox_workspace_mount_mode() == "bind"
else:
with pytest.raises(ValueError, match=SANDBOX_WORKSPACE_MOUNT_MODE):
get_sandbox_workspace_mount_mode()
@pytest.mark.parametrize("value", ["/host/path", "bad volume", "a"])
def test_invalid_volume_name_is_rejected(self, monkeypatch, value):
monkeypatch.setenv(SANDBOX_WORKSPACE_VOLUME, value)
with pytest.raises(ValueError, match="Docker volume name"):
get_sandbox_workspace_volume()
def test_relative_volume_root_is_rejected(self, monkeypatch):
monkeypatch.setenv(SANDBOX_WORKSPACE_VOLUME_ROOT, "uploads")
with pytest.raises(ValueError, match="absolute path"):
get_sandbox_workspace_volume_root()
class TestGetMaxTracePayloadBytes:
"""Test get_max_trace_payload_bytes() function."""
def test_default(self, monkeypatch):
monkeypatch.delenv(MAX_TRACE_PAYLOAD_BYTES, raising=False)
assert get_max_trace_payload_bytes() == 50_000
def test_env_override(self, monkeypatch):
monkeypatch.setenv(MAX_TRACE_PAYLOAD_BYTES, "1234")
assert get_max_trace_payload_bytes() == 1234
def test_zero_passes_through(self, monkeypatch):
"""Zero disables truncation (handled by truncate_for_trace)."""
monkeypatch.setenv(MAX_TRACE_PAYLOAD_BYTES, "0")
assert get_max_trace_payload_bytes() == 0
def test_invalid_falls_back_to_default(self, monkeypatch):
monkeypatch.setenv(MAX_TRACE_PAYLOAD_BYTES, "not-a-number")
assert get_max_trace_payload_bytes() == 50_000
def test_negative_falls_back_to_default(self, monkeypatch):
monkeypatch.setenv(MAX_TRACE_PAYLOAD_BYTES, "-100")
assert get_max_trace_payload_bytes() == 50_000
class TestToolConcurrencyConfig:
"""Config for in-turn tool concurrency (design §7)."""
def test_parallel_enabled_default_is_false(self, monkeypatch):
from xagent.config import get_tool_parallel_enabled
monkeypatch.delenv("XAGENT_TOOL_PARALLEL_ENABLED", raising=False)
assert get_tool_parallel_enabled() is False
def test_parallel_enabled_env_override(self, monkeypatch):
from xagent.config import get_tool_parallel_enabled
monkeypatch.setenv("XAGENT_TOOL_PARALLEL_ENABLED", "true")
assert get_tool_parallel_enabled() is True
monkeypatch.setenv("XAGENT_TOOL_PARALLEL_ENABLED", "0")
assert get_tool_parallel_enabled() is False
def test_max_concurrency_default_is_three(self, monkeypatch):
from xagent.config import get_tool_max_concurrency
monkeypatch.delenv("XAGENT_TOOL_MAX_CONCURRENCY", raising=False)
assert get_tool_max_concurrency() == 3
def test_max_concurrency_env_override(self, monkeypatch):
from xagent.config import get_tool_max_concurrency
monkeypatch.setenv("XAGENT_TOOL_MAX_CONCURRENCY", "8")
assert get_tool_max_concurrency() == 8
def test_max_concurrency_invalid_falls_back_to_default(self, monkeypatch):
from xagent.config import get_tool_max_concurrency
monkeypatch.setenv("XAGENT_TOOL_MAX_CONCURRENCY", "not-a-number")
assert get_tool_max_concurrency() == 3
monkeypatch.setenv("XAGENT_TOOL_MAX_CONCURRENCY", "0")
assert get_tool_max_concurrency() == 3
class TestTaskRuntimeHookConfig:
def test_defaults(self, monkeypatch):
monkeypatch.delenv(TASK_RUNTIME_HOOK_MAX_WORKERS, raising=False)
monkeypatch.delenv(TASK_RUNTIME_HOOK_QUEUE_TIMEOUT_SECONDS, raising=False)
assert get_task_runtime_hook_max_workers() == 8
assert get_task_runtime_hook_queue_timeout_seconds() == 30
def test_env_overrides(self, monkeypatch):
monkeypatch.setenv(TASK_RUNTIME_HOOK_MAX_WORKERS, "12")
monkeypatch.setenv(TASK_RUNTIME_HOOK_QUEUE_TIMEOUT_SECONDS, "45")
assert get_task_runtime_hook_max_workers() == 12
assert get_task_runtime_hook_queue_timeout_seconds() == 45
def test_invalid_values_fall_back(self, monkeypatch):
monkeypatch.setenv(TASK_RUNTIME_HOOK_MAX_WORKERS, "0")
monkeypatch.setenv(TASK_RUNTIME_HOOK_QUEUE_TIMEOUT_SECONDS, "invalid")
assert get_task_runtime_hook_max_workers() == 8
assert get_task_runtime_hook_queue_timeout_seconds() == 30
class TestLocalBrowserConfig:
def test_defaults(self, monkeypatch):
for name in (
NATIVE_BROWSER_ENABLED,
NATIVE_BROWSER_APP_NAME,
BROWSER_CUA_DRIVER_COMMAND,
BROWSER_CUA_DRIVER_SOCKET,
BROWSER_CUA_DRIVER_TIMEOUT_SECONDS,
BROWSER_CUA_DRIVER_MAX_ELEMENTS,
):
monkeypatch.delenv(name, raising=False)
assert get_native_browser_enabled() is False
assert get_native_browser_app_name() == "Google Chrome"
assert get_browser_cua_driver_command() == "cua-driver"
assert get_browser_cua_driver_socket() is None
assert get_browser_cua_driver_timeout_seconds() == 30
assert get_browser_cua_driver_max_elements() == 2_000
def test_env_overrides(self, monkeypatch):
monkeypatch.setenv(NATIVE_BROWSER_ENABLED, "true")
monkeypatch.setenv(NATIVE_BROWSER_APP_NAME, "Chromium")
monkeypatch.setenv(BROWSER_CUA_DRIVER_COMMAND, "/opt/bin/cua-driver")
monkeypatch.setenv(BROWSER_CUA_DRIVER_SOCKET, "/tmp/cua.sock")
monkeypatch.setenv(BROWSER_CUA_DRIVER_TIMEOUT_SECONDS, "12.5")
monkeypatch.setenv(BROWSER_CUA_DRIVER_MAX_ELEMENTS, "250")
assert get_native_browser_enabled() is True
assert get_native_browser_app_name() == "Chromium"
assert get_browser_cua_driver_command() == "/opt/bin/cua-driver"
assert get_browser_cua_driver_socket() == "/tmp/cua.sock"
assert get_browser_cua_driver_timeout_seconds() == 12.5
assert get_browser_cua_driver_max_elements() == 250
def test_invalid_values_fall_back(self, monkeypatch):
monkeypatch.setenv(BROWSER_CUA_DRIVER_TIMEOUT_SECONDS, "0")
monkeypatch.setenv(BROWSER_CUA_DRIVER_MAX_ELEMENTS, "invalid")
assert get_browser_cua_driver_timeout_seconds() == 30
assert get_browser_cua_driver_max_elements() == 2_000
def test_rejects_non_browser_native_application(self, monkeypatch):
monkeypatch.setenv(NATIVE_BROWSER_APP_NAME, "Terminal")
with pytest.raises(ValueError, match="must name a supported browser"):
get_native_browser_app_name()
class TestBrowserToolDefaultLocaleConfig:
"""Fallback locale/timezone for browser_use (Playwright) sessions."""
def test_defaults(self, monkeypatch):
monkeypatch.delenv(config.BROWSER_TOOL_DEFAULT_LOCALE, raising=False)
monkeypatch.delenv(config.BROWSER_TOOL_DEFAULT_TIMEZONE, raising=False)
assert config.get_browser_tool_default_locale() == "en-US"
assert config.get_browser_tool_default_timezone() is None
def test_env_overrides(self, monkeypatch):
monkeypatch.setenv(config.BROWSER_TOOL_DEFAULT_LOCALE, "ja-JP")
monkeypatch.setenv(config.BROWSER_TOOL_DEFAULT_TIMEZONE, "Asia/Tokyo")
assert config.get_browser_tool_default_locale() == "ja-JP"
assert config.get_browser_tool_default_timezone() == "Asia/Tokyo"
def test_blank_values_fall_back(self, monkeypatch):
monkeypatch.setenv(config.BROWSER_TOOL_DEFAULT_LOCALE, " ")
monkeypatch.setenv(config.BROWSER_TOOL_DEFAULT_TIMEZONE, "")
assert config.get_browser_tool_default_locale() == "en-US"
assert config.get_browser_tool_default_timezone() is None
class TestBrowserSandboxConfig:
def test_defaults_to_sandboxed(self, monkeypatch):
monkeypatch.delenv(config.BROWSER_ALLOW_UNSANDBOXED, raising=False)
assert config.get_browser_allow_unsandboxed() is False
def test_env_override(self, monkeypatch):
monkeypatch.setenv(config.BROWSER_ALLOW_UNSANDBOXED, "true")
assert config.get_browser_allow_unsandboxed() is True
class TestBrowserRunAsConfig:
def test_unset_returns_none(self, monkeypatch):
monkeypatch.delenv(config.BROWSER_RUN_AS_UID, raising=False)
monkeypatch.delenv(config.BROWSER_RUN_AS_GID, raising=False)
assert config.get_browser_run_as() is None
@pytest.mark.parametrize(("uid", "gid"), [("", ""), (" ", "\t")])
def test_blank_values_return_none(self, monkeypatch, uid, gid):
monkeypatch.setenv(config.BROWSER_RUN_AS_UID, uid)
monkeypatch.setenv(config.BROWSER_RUN_AS_GID, gid)
assert config.get_browser_run_as() is None
@pytest.mark.parametrize(("uid", "gid"), [("", "1000"), ("1000", " ")])
def test_one_blank_value_requires_both(self, monkeypatch, uid, gid):
monkeypatch.setenv(config.BROWSER_RUN_AS_UID, uid)
monkeypatch.setenv(config.BROWSER_RUN_AS_GID, gid)
with pytest.raises(ValueError, match="must be set together"):
config.get_browser_run_as()
def test_both_set_returns_tuple(self, monkeypatch):
monkeypatch.setenv(config.BROWSER_RUN_AS_UID, "1000")
monkeypatch.setenv(config.BROWSER_RUN_AS_GID, "1001")
assert config.get_browser_run_as() == (1000, 1001)
@pytest.mark.parametrize(
("uid", "gid"),
[
("1000", None),
(None, "1000"),
("not-a-number", "1000"),
("1000", "not-a-number"),
("0", "1000"),
("1000", "0"),
("-1", "1000"),
("1000", "-2"),
("4294967295", "1000"),
],
)
def test_invalid_settings_raise(self, monkeypatch, uid, gid):
for name, value in (
(config.BROWSER_RUN_AS_UID, uid),
(config.BROWSER_RUN_AS_GID, gid),
):
if value is None:
monkeypatch.delenv(name, raising=False)
else:
monkeypatch.setenv(name, value)
with pytest.raises(ValueError):
config.get_browser_run_as()
class TestCheckpointStorageConfig:
"""Config for checkpoint trace-event storage encoding and retention."""
def test_encoding_v2_default_is_true(self, monkeypatch):
from xagent.config import get_checkpoint_encoding_v2_enabled
monkeypatch.delenv("XAGENT_CHECKPOINT_ENCODING_V2", raising=False)
assert get_checkpoint_encoding_v2_enabled() is True
def test_encoding_v2_env_override(self, monkeypatch):
from xagent.config import get_checkpoint_encoding_v2_enabled
monkeypatch.setenv("XAGENT_CHECKPOINT_ENCODING_V2", "false")
assert get_checkpoint_encoding_v2_enabled() is False
monkeypatch.setenv("XAGENT_CHECKPOINT_ENCODING_V2", "1")
assert get_checkpoint_encoding_v2_enabled() is True
def test_history_limit_default_is_eight(self, monkeypatch):
from xagent.config import get_checkpoint_history_limit
monkeypatch.delenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", raising=False)
assert get_checkpoint_history_limit() == 8
def test_history_limit_env_override_and_zero_disables(self, monkeypatch):
from xagent.config import get_checkpoint_history_limit
monkeypatch.setenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", "20")
assert get_checkpoint_history_limit() == 20
monkeypatch.setenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", "0")
assert get_checkpoint_history_limit() == 0
def test_history_limit_invalid_falls_back_to_default(self, monkeypatch):
from xagent.config import get_checkpoint_history_limit
monkeypatch.setenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", "not-a-number")
assert get_checkpoint_history_limit() == 8
monkeypatch.setenv("XAGENT_CHECKPOINT_HISTORY_LIMIT", "-1")
assert get_checkpoint_history_limit() == 8
class TestSandboxConcurrencyConfig:
"""Config for sandbox worker concurrency."""
def test_sandbox_max_concurrency_default_is_three(self, monkeypatch):
from xagent.config import get_sandbox_max_concurrency
monkeypatch.delenv("XAGENT_SANDBOX_MAX_CONCURRENCY", raising=False)
assert get_sandbox_max_concurrency() == 3
def test_sandbox_max_concurrency_env_override(self, monkeypatch):
from xagent.config import get_sandbox_max_concurrency
monkeypatch.setenv("XAGENT_SANDBOX_MAX_CONCURRENCY", "5")
assert get_sandbox_max_concurrency() == 5
def test_sandbox_max_concurrency_invalid_falls_back_to_default(self, monkeypatch):
from xagent.config import get_sandbox_max_concurrency
monkeypatch.setenv("XAGENT_SANDBOX_MAX_CONCURRENCY", "not-a-number")
assert get_sandbox_max_concurrency() == 3
monkeypatch.setenv("XAGENT_SANDBOX_MAX_CONCURRENCY", "0")
assert get_sandbox_max_concurrency() == 3
class TestTriggerRateLimitConfig:
"""Config for trigger callback and CRUD rate limits."""
def test_callback_rate_limit_default(self, monkeypatch):
from xagent.config import get_trigger_callback_rate_limit
monkeypatch.delenv("XAGENT_TRIGGER_CALLBACK_RATE_LIMIT", raising=False)
assert get_trigger_callback_rate_limit() == "120/minute"
def test_callback_rate_limit_env_override(self, monkeypatch):
from xagent.config import get_trigger_callback_rate_limit
monkeypatch.setenv("XAGENT_TRIGGER_CALLBACK_RATE_LIMIT", "10/second")
assert get_trigger_callback_rate_limit() == "10/second"
def test_crud_rate_limit_default(self, monkeypatch):
from xagent.config import get_trigger_crud_rate_limit
monkeypatch.delenv("XAGENT_TRIGGER_CRUD_RATE_LIMIT", raising=False)
assert get_trigger_crud_rate_limit() == "60/minute"
def test_crud_rate_limit_env_override(self, monkeypatch):
from xagent.config import get_trigger_crud_rate_limit
monkeypatch.setenv("XAGENT_TRIGGER_CRUD_RATE_LIMIT", "5/minute")
assert get_trigger_crud_rate_limit() == "5/minute"
class TestShareRateLimitConfig:
"""Config for public share-channel rate limits and run quotas (#973)."""
_CASES = [
("get_share_auth_rate_limit", "XAGENT_SHARE_AUTH_RATE_LIMIT", "60/minute"),
(
"get_share_auth_ip_rate_limit",
"XAGENT_SHARE_AUTH_IP_RATE_LIMIT",
"300/minute",
),
(
"get_share_task_create_rate_limit",
"XAGENT_SHARE_TASK_CREATE_RATE_LIMIT",
"30/minute",
),
(
"get_share_task_create_token_rate_limit",
"XAGENT_SHARE_TASK_CREATE_TOKEN_RATE_LIMIT",
"120/minute",
),
(
"get_share_ws_turn_rate_limit",
"XAGENT_SHARE_WS_TURN_RATE_LIMIT",
"60/minute",
),
(
"get_share_ws_connect_ip_rate_limit",
"XAGENT_SHARE_WS_CONNECT_IP_RATE_LIMIT",
"120/minute",
),
("get_share_upload_rate_limit", "XAGENT_SHARE_UPLOAD_RATE_LIMIT", "60/minute"),
(
"get_widget_upload_rate_limit",
"XAGENT_WIDGET_UPLOAD_RATE_LIMIT",
"240/minute",
),
(
"get_widget_upload_ip_rate_limit",
"XAGENT_WIDGET_UPLOAD_IP_RATE_LIMIT",
"60/minute",
),
("get_share_run_quota", "XAGENT_SHARE_RUN_QUOTA", "500/day"),
("get_share_run_guest_quota", "XAGENT_SHARE_RUN_GUEST_QUOTA", "60/hour"),
(
"get_widget_ws_connect_ip_rate_limit",
"XAGENT_WIDGET_WS_CONNECT_IP_RATE_LIMIT",
"120/minute",
),
(
"get_widget_ws_turn_ip_rate_limit",
"XAGENT_WIDGET_WS_TURN_IP_RATE_LIMIT",
"60/minute",
),
(
"get_widget_ws_turn_rate_limit",
"XAGENT_WIDGET_WS_TURN_RATE_LIMIT",
"240/minute",
),
(
"get_widget_auth_rate_limit",
"XAGENT_WIDGET_AUTH_RATE_LIMIT",
"1200/minute",
),
(
"get_widget_auth_ip_rate_limit",
"XAGENT_WIDGET_AUTH_IP_RATE_LIMIT",
"300/minute",
),
(
"get_widget_task_create_rate_limit",
"XAGENT_WIDGET_TASK_CREATE_RATE_LIMIT",
"240/minute",
),
(
"get_widget_task_create_ip_rate_limit",
"XAGENT_WIDGET_TASK_CREATE_IP_RATE_LIMIT",
"60/minute",
),
("get_widget_run_quota", "XAGENT_WIDGET_RUN_QUOTA", "500/day"),
("get_widget_run_ip_quota", "XAGENT_WIDGET_RUN_IP_QUOTA", "120/hour"),
]
@pytest.mark.parametrize("func_name,env_var,default", _CASES)
def test_default(self, monkeypatch, func_name, env_var, default):
import xagent.config as config
monkeypatch.delenv(env_var, raising=False)
assert getattr(config, func_name)() == default
@pytest.mark.parametrize("func_name,env_var,default", _CASES)
def test_env_override(self, monkeypatch, func_name, env_var, default):
import xagent.config as config
monkeypatch.setenv(env_var, "7/second")
assert getattr(config, func_name)() == "7/second"
@pytest.mark.parametrize("func_name,env_var,default", _CASES)
def test_blank_env_falls_back_to_default(
self, monkeypatch, func_name, env_var, default
):
import xagent.config as config
monkeypatch.setenv(env_var, " ")
assert getattr(config, func_name)() == default
class TestOrphanUploadGcConfig:
"""Config for task-less public-upload orphan GC (#973)."""
def test_ttl_default(self, monkeypatch):
from xagent.config import get_taskless_upload_ttl_seconds
monkeypatch.delenv("XAGENT_TASKLESS_UPLOAD_TTL_SECONDS", raising=False)
assert get_taskless_upload_ttl_seconds() == 48 * 60 * 60
def test_ttl_env_override(self, monkeypatch):
from xagent.config import get_taskless_upload_ttl_seconds
monkeypatch.setenv("XAGENT_TASKLESS_UPLOAD_TTL_SECONDS", "86400")
assert get_taskless_upload_ttl_seconds() == 86400
def test_ttl_below_minimum_falls_back_to_default(self, monkeypatch):
from xagent.config import get_taskless_upload_ttl_seconds
# Below the 1h floor -> default (guards against reaping mid-first-turn).
monkeypatch.setenv("XAGENT_TASKLESS_UPLOAD_TTL_SECONDS", "5")
assert get_taskless_upload_ttl_seconds() == 48 * 60 * 60
def test_sweep_interval_default(self, monkeypatch):
from xagent.config import get_orphan_upload_sweep_interval_seconds
monkeypatch.delenv("XAGENT_ORPHAN_UPLOAD_SWEEP_INTERVAL_SECONDS", raising=False)
assert get_orphan_upload_sweep_interval_seconds() == 3600
def test_sweep_interval_env_override(self, monkeypatch):
from xagent.config import get_orphan_upload_sweep_interval_seconds
monkeypatch.setenv("XAGENT_ORPHAN_UPLOAD_SWEEP_INTERVAL_SECONDS", "900")
assert get_orphan_upload_sweep_interval_seconds() == 900
class TestComposioReconcileConfig:
"""How often unbound Composio accounts are cleaned up (#3548)."""
def test_off_unless_set(self, monkeypatch):
from xagent.config import get_composio_reconcile_interval_seconds
monkeypatch.delenv("XAGENT_COMPOSIO_RECONCILE_INTERVAL_SECONDS", raising=False)
assert get_composio_reconcile_interval_seconds() is None
monkeypatch.setenv("XAGENT_COMPOSIO_RECONCILE_INTERVAL_SECONDS", " ")
assert get_composio_reconcile_interval_seconds() is None
def test_a_set_interval_has_a_floor(self, monkeypatch):
from xagent.config import get_composio_reconcile_interval_seconds
monkeypatch.setenv("XAGENT_COMPOSIO_RECONCILE_INTERVAL_SECONDS", "900")
assert get_composio_reconcile_interval_seconds() == 900
for invalid in ("5", "hourly"):
monkeypatch.setenv("XAGENT_COMPOSIO_RECONCILE_INTERVAL_SECONDS", invalid)
assert get_composio_reconcile_interval_seconds() is None
class TestComposioMissingAccountConfig:
"""How often grants whose Composio account is gone are cleared."""
def test_on_by_default(self, monkeypatch):
from xagent.config import get_composio_missing_account_interval_seconds
monkeypatch.delenv(
"XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", raising=False
)
assert get_composio_missing_account_interval_seconds() == 3600
monkeypatch.setenv("XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", " ")
assert get_composio_missing_account_interval_seconds() == 3600
def test_zero_turns_it_off(self, monkeypatch):
from xagent.config import get_composio_missing_account_interval_seconds
monkeypatch.setenv("XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", "0")
assert get_composio_missing_account_interval_seconds() == 0
def test_a_set_interval_has_a_floor(self, monkeypatch):
from xagent.config import get_composio_missing_account_interval_seconds
monkeypatch.setenv("XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", "900")
assert get_composio_missing_account_interval_seconds() == 900
for invalid in ("5", "hourly", "-1"):
monkeypatch.setenv(
"XAGENT_COMPOSIO_MISSING_ACCOUNT_INTERVAL_SECONDS", invalid
)
assert get_composio_missing_account_interval_seconds() == 3600
class TestTaskCleanupRetryConfig:
"""Config for retrying the external cleanup a task deletion owes (#2587)."""
def test_retry_interval_default(self, monkeypatch):
from xagent.config import get_task_cleanup_retry_interval_seconds
monkeypatch.delenv("XAGENT_TASK_CLEANUP_RETRY_INTERVAL_SECONDS", raising=False)
assert get_task_cleanup_retry_interval_seconds() == 300
def test_retry_interval_env_override(self, monkeypatch):
from xagent.config import get_task_cleanup_retry_interval_seconds
monkeypatch.setenv("XAGENT_TASK_CLEANUP_RETRY_INTERVAL_SECONDS", "120")
assert get_task_cleanup_retry_interval_seconds() == 120
def test_retry_interval_below_minimum_falls_back_to_default(self, monkeypatch):
from xagent.config import get_task_cleanup_retry_interval_seconds
monkeypatch.setenv("XAGENT_TASK_CLEANUP_RETRY_INTERVAL_SECONDS", "1")
assert get_task_cleanup_retry_interval_seconds() == 300
def test_max_attempts_default(self, monkeypatch):
from xagent.config import get_task_cleanup_max_attempts
monkeypatch.delenv("XAGENT_TASK_CLEANUP_MAX_ATTEMPTS", raising=False)
assert get_task_cleanup_max_attempts() == 8
def test_max_attempts_env_override(self, monkeypatch):
from xagent.config import get_task_cleanup_max_attempts
monkeypatch.setenv("XAGENT_TASK_CLEANUP_MAX_ATTEMPTS", "3")
assert get_task_cleanup_max_attempts() == 3
def test_max_attempts_zero_falls_back_to_default(self, monkeypatch):
from xagent.config import get_task_cleanup_max_attempts
monkeypatch.setenv("XAGENT_TASK_CLEANUP_MAX_ATTEMPTS", "0")
assert get_task_cleanup_max_attempts() == 8
class TestLlmRetryBudgetConfig:
"""#2605: the two bounds that attempt counting cannot express."""
def test_deadline_default(self, monkeypatch):
from xagent.config import get_llm_retry_deadline_seconds
monkeypatch.delenv("XAGENT_LLM_RETRY_DEADLINE_SECONDS", raising=False)
assert get_llm_retry_deadline_seconds() == 300.0
def test_deadline_env_override(self, monkeypatch):
from xagent.config import get_llm_retry_deadline_seconds
monkeypatch.setenv("XAGENT_LLM_RETRY_DEADLINE_SECONDS", "45.5")
assert get_llm_retry_deadline_seconds() == 45.5
@pytest.mark.parametrize(
"value", ["", " ", "not-a-number", "0", "-5", "nan", "inf"]
)
def test_deadline_rejects_unusable_values(self, monkeypatch, value):
"""An unbounded loop is the bug; never let bad config reintroduce it."""
from xagent.config import get_llm_retry_deadline_seconds
monkeypatch.setenv("XAGENT_LLM_RETRY_DEADLINE_SECONDS", value)
assert get_llm_retry_deadline_seconds() == 300.0
def test_capacity_attempts_default(self, monkeypatch):
from xagent.config import get_llm_capacity_max_attempts
monkeypatch.delenv("XAGENT_LLM_CAPACITY_MAX_ATTEMPTS", raising=False)
assert get_llm_capacity_max_attempts() == 2
def test_capacity_attempts_env_override(self, monkeypatch):
from xagent.config import get_llm_capacity_max_attempts
monkeypatch.setenv("XAGENT_LLM_CAPACITY_MAX_ATTEMPTS", "1")
assert get_llm_capacity_max_attempts() == 1
@pytest.mark.parametrize("value", ["", "1.5", "not-a-number", "0", "-3"])
def test_capacity_attempts_rejects_unusable_values(self, monkeypatch, value):
from xagent.config import get_llm_capacity_max_attempts
monkeypatch.setenv("XAGENT_LLM_CAPACITY_MAX_ATTEMPTS", value)
assert get_llm_capacity_max_attempts() == 2
def test_auto_primary_attempts_default(self, monkeypatch):
from xagent.config import get_auto_primary_max_attempts
monkeypatch.delenv("XAGENT_AUTO_PRIMARY_MAX_ATTEMPTS", raising=False)
assert get_auto_primary_max_attempts() == 2
def test_auto_primary_attempts_env_override(self, monkeypatch):
from xagent.config import get_auto_primary_max_attempts
monkeypatch.setenv("XAGENT_AUTO_PRIMARY_MAX_ATTEMPTS", "3")
assert get_auto_primary_max_attempts() == 3
@pytest.mark.parametrize("value", ["", "1.5", "not-a-number", "0", "-3"])
def test_auto_primary_attempts_rejects_unusable_values(self, monkeypatch, value):
from xagent.config import get_auto_primary_max_attempts
monkeypatch.setenv("XAGENT_AUTO_PRIMARY_MAX_ATTEMPTS", value)
assert get_auto_primary_max_attempts() == 2
def test_auto_candidate_cooldown_default(self, monkeypatch):
from xagent.config import get_auto_candidate_cooldown_seconds
monkeypatch.delenv("XAGENT_AUTO_CANDIDATE_COOLDOWN_SECONDS", raising=False)
assert get_auto_candidate_cooldown_seconds() == 300.0
def test_auto_candidate_cooldown_env_override(self, monkeypatch):
from xagent.config import get_auto_candidate_cooldown_seconds
monkeypatch.setenv("XAGENT_AUTO_CANDIDATE_COOLDOWN_SECONDS", "45.5")
assert get_auto_candidate_cooldown_seconds() == 45.5
@pytest.mark.parametrize("value", ["", "not-a-number", "0", "-3", "nan", "inf"])
def test_auto_candidate_cooldown_rejects_unusable_values(self, monkeypatch, value):
from xagent.config import get_auto_candidate_cooldown_seconds
monkeypatch.setenv("XAGENT_AUTO_CANDIDATE_COOLDOWN_SECONDS", value)
assert get_auto_candidate_cooldown_seconds() == 300.0
class TestConnectorProbeUsersConfig:
def test_connector_probe_users_unset(self, monkeypatch):
from xagent.config import get_connector_probe_users
monkeypatch.delenv("XAGENT_CONNECTOR_PROBE_USERS", raising=False)
result = get_connector_probe_users()
assert result == frozenset()
assert isinstance(result, frozenset)
def test_connector_probe_users_parses_and_strips(self, monkeypatch):
from xagent.config import get_connector_probe_users
monkeypatch.setenv(
"XAGENT_CONNECTOR_PROBE_USERS", " [email protected] , ops,, "
)
assert get_connector_probe_users() == {"[email protected]", "ops"}
def test_connector_probe_users_blank(self, monkeypatch):
from xagent.config import get_connector_probe_users
monkeypatch.setenv("XAGENT_CONNECTOR_PROBE_USERS", " , ")
assert get_connector_probe_users() == frozenset()
class TestConnectorSmokeWriteAppsConfig:
"""#3564: the connectors whose smoke V2 write checks may run."""
def test_unset_runs_no_write_check(self, monkeypatch):
from xagent.config import get_connector_smoke_write_apps
monkeypatch.delenv("XAGENT_CONNECTOR_SMOKE_WRITE_APPS", raising=False)
result = get_connector_smoke_write_apps()
assert result == frozenset()
assert isinstance(result, frozenset)
def test_parses_and_strips_app_ids(self, monkeypatch):
from xagent.config import get_connector_smoke_write_apps
monkeypatch.setenv(
"XAGENT_CONNECTOR_SMOKE_WRITE_APPS", " jira , google-drive,, "
)
assert get_connector_smoke_write_apps() == {"jira", "google-drive"}
def test_blank_runs_no_write_check(self, monkeypatch):
from xagent.config import get_connector_smoke_write_apps
monkeypatch.setenv("XAGENT_CONNECTOR_SMOKE_WRITE_APPS", " , ")
assert get_connector_smoke_write_apps() == frozenset()
class TestLlmStreamProgressConfig:
"""#2785: knobs for aborting an OpenAI-compatible LLM stream that stops
making progress."""
def test_empty_delta_limit_default(self, monkeypatch):
from xagent.config import get_llm_stream_empty_delta_limit
monkeypatch.delenv("XAGENT_LLM_STREAM_EMPTY_DELTA_LIMIT", raising=False)
assert get_llm_stream_empty_delta_limit() == 200
def test_empty_delta_limit_env_override(self, monkeypatch):
from xagent.config import get_llm_stream_empty_delta_limit
monkeypatch.setenv("XAGENT_LLM_STREAM_EMPTY_DELTA_LIMIT", "50")
assert get_llm_stream_empty_delta_limit() == 50
def test_empty_delta_limit_zero_disables(self, monkeypatch):
"""0 is a valid, explicit way to disable the check."""
from xagent.config import get_llm_stream_empty_delta_limit
monkeypatch.setenv("XAGENT_LLM_STREAM_EMPTY_DELTA_LIMIT", "0")
assert get_llm_stream_empty_delta_limit() == 0
@pytest.mark.parametrize("value", ["abc", "-5"])
def test_empty_delta_limit_rejects_unusable_values(self, monkeypatch, value):
from xagent.config import get_llm_stream_empty_delta_limit
monkeypatch.setenv("XAGENT_LLM_STREAM_EMPTY_DELTA_LIMIT", value)
assert get_llm_stream_empty_delta_limit() == 200
def test_degenerate_window_default(self, monkeypatch):
from xagent.config import get_llm_stream_degenerate_window
monkeypatch.delenv("XAGENT_LLM_STREAM_DEGENERATE_WINDOW", raising=False)
assert get_llm_stream_degenerate_window() == 256
def test_degenerate_window_env_override(self, monkeypatch):
from xagent.config import get_llm_stream_degenerate_window
monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_WINDOW", "128")
assert get_llm_stream_degenerate_window() == 128
def test_degenerate_window_zero_disables(self, monkeypatch):
"""0 is a valid, explicit way to disable the check."""
from xagent.config import get_llm_stream_degenerate_window
monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_WINDOW", "0")
assert get_llm_stream_degenerate_window() == 0
@pytest.mark.parametrize("value", ["abc", "-5"])
def test_degenerate_window_rejects_unusable_values(self, monkeypatch, value):
from xagent.config import get_llm_stream_degenerate_window
monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_WINDOW", value)
assert get_llm_stream_degenerate_window() == 256
def test_degenerate_max_period_default(self, monkeypatch):
from xagent.config import get_llm_stream_degenerate_max_period
monkeypatch.delenv("XAGENT_LLM_STREAM_DEGENERATE_MAX_PERIOD", raising=False)
assert get_llm_stream_degenerate_max_period() == 64
def test_degenerate_max_period_env_override(self, monkeypatch):
from xagent.config import get_llm_stream_degenerate_max_period
monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_MAX_PERIOD", "32")
assert get_llm_stream_degenerate_max_period() == 32
@pytest.mark.parametrize("value", ["abc", "-5", "0"])
def test_degenerate_max_period_rejects_unusable_values(self, monkeypatch, value):
"""Unlike the window/limit knobs, 0 is below the minimum of 1 here."""
from xagent.config import get_llm_stream_degenerate_max_period
monkeypatch.setenv("XAGENT_LLM_STREAM_DEGENERATE_MAX_PERIOD", value)
assert get_llm_stream_degenerate_max_period() == 64
def test_no_payload_abort_models_unset(self, monkeypatch):
from xagent.config import get_llm_stream_no_payload_abort_models
monkeypatch.delenv("XAGENT_LLM_STREAM_NO_PAYLOAD_ABORT_MODELS", raising=False)
result = get_llm_stream_no_payload_abort_models()
assert result == frozenset()
assert isinstance(result, frozenset)
def test_no_payload_abort_models_parses_and_strips(self, monkeypatch):
from xagent.config import get_llm_stream_no_payload_abort_models
monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_ABORT_MODELS", " a , b,,c ")
result = get_llm_stream_no_payload_abort_models()
assert result == {"a", "b", "c"}
assert isinstance(result, frozenset)
def test_no_payload_abort_models_blank(self, monkeypatch):
from xagent.config import get_llm_stream_no_payload_abort_models
monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_ABORT_MODELS", " ")
result = get_llm_stream_no_payload_abort_models()
assert result == frozenset()
assert isinstance(result, frozenset)
def test_no_payload_timeout_invalid_value_logs_the_real_default(
self, monkeypatch, caplog
):
import logging
from xagent.config import get_llm_stream_no_payload_timeout_seconds
monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_TIMEOUT_SECONDS", "abc")
with caplog.at_level(logging.WARNING, logger="xagent.config"):
assert get_llm_stream_no_payload_timeout_seconds() == 30.0
assert any("falling back to 30.0" in r.getMessage() for r in caplog.records)
def test_retry_deadline_invalid_value_logs_the_real_default(
self, monkeypatch, caplog
):
import logging
from xagent.config import get_llm_retry_deadline_seconds
monkeypatch.setenv("XAGENT_LLM_RETRY_DEADLINE_SECONDS", "abc")
with caplog.at_level(logging.WARNING, logger="xagent.config"):
assert get_llm_retry_deadline_seconds() == 300.0
assert any("falling back to 300.0" in r.getMessage() for r in caplog.records)
def test_no_payload_timeout_default(self, monkeypatch):
from xagent.config import get_llm_stream_no_payload_timeout_seconds
monkeypatch.delenv(
"XAGENT_LLM_STREAM_NO_PAYLOAD_TIMEOUT_SECONDS", raising=False
)
assert get_llm_stream_no_payload_timeout_seconds() == 30.0
def test_no_payload_timeout_env_override(self, monkeypatch):
from xagent.config import get_llm_stream_no_payload_timeout_seconds
monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_TIMEOUT_SECONDS", "15.5")
assert get_llm_stream_no_payload_timeout_seconds() == 15.5
@pytest.mark.parametrize("value", ["0", "nan", "abc"])
def test_no_payload_timeout_rejects_unusable_values(self, monkeypatch, value):
from xagent.config import get_llm_stream_no_payload_timeout_seconds
monkeypatch.setenv("XAGENT_LLM_STREAM_NO_PAYLOAD_TIMEOUT_SECONDS", value)
assert get_llm_stream_no_payload_timeout_seconds() == 30.0
class TestWorkforcePreviewRunReapConfig:
"""PR #1060 review: get_workforce_preview_run_stale_seconds() had no
test, unlike its sibling TTL config functions above."""
def test_default(self, monkeypatch):
from xagent.config import get_workforce_preview_run_stale_seconds
monkeypatch.delenv("XAGENT_WORKFORCE_PREVIEW_RUN_STALE_SECONDS", raising=False)
assert get_workforce_preview_run_stale_seconds() == 7200
def test_env_override(self, monkeypatch):
from xagent.config import get_workforce_preview_run_stale_seconds
monkeypatch.setenv("XAGENT_WORKFORCE_PREVIEW_RUN_STALE_SECONDS", "3600")
assert get_workforce_preview_run_stale_seconds() == 3600
def test_below_minimum_falls_back_to_default(self, monkeypatch):
from xagent.config import get_workforce_preview_run_stale_seconds
# Below the 300s floor -> default (guards against reaping a preview
# run that is still genuinely in progress).
monkeypatch.setenv("XAGENT_WORKFORCE_PREVIEW_RUN_STALE_SECONDS", "5")
assert get_workforce_preview_run_stale_seconds() == 7200
def test_invalid_value_falls_back_to_default(self, monkeypatch):
from xagent.config import get_workforce_preview_run_stale_seconds
monkeypatch.setenv("XAGENT_WORKFORCE_PREVIEW_RUN_STALE_SECONDS", "not-a-number")
assert get_workforce_preview_run_stale_seconds() == 7200
class TestGmailPubSubProvisioningConfig:
"""Config for per-mailbox Gmail Pub/Sub provisioning."""
def test_constants(self):
assert GMAIL_PUBSUB_PROJECT_ID == "XAGENT_GMAIL_PUBSUB_PROJECT_ID"
assert GMAIL_PUBSUB_TOPIC_PREFIX == "XAGENT_GMAIL_PUBSUB_TOPIC_PREFIX"
assert (
GMAIL_PUBSUB_SUBSCRIPTION_PREFIX
== "XAGENT_GMAIL_PUBSUB_SUBSCRIPTION_PREFIX"
)
assert (
GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT
== "XAGENT_GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT"
)
assert (
GMAIL_REGISTRATION_TIMEOUT_SECONDS
== "XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS"
)
assert PUBLIC_API_BASE_URL == "XAGENT_PUBLIC_API_BASE_URL"
assert S2S_API_BASE_URL == "XAGENT_S2S_API_BASE_URL"
def test_defaults(self, monkeypatch):
monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_PROJECT_ID", raising=False)
monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_TOPIC_PREFIX", raising=False)
monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_SUBSCRIPTION_PREFIX", raising=False)
monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT", raising=False)
monkeypatch.delenv("XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS", raising=False)
monkeypatch.delenv("XAGENT_PUBLIC_API_BASE_URL", raising=False)
monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)
assert get_gmail_pubsub_project_id() is None
assert get_gmail_pubsub_topic_prefix() == "xagent-gmail"
assert get_gmail_pubsub_subscription_prefix() == "xagent-gmail-push"
assert get_gmail_pubsub_push_service_account() is None
assert get_gmail_registration_timeout_seconds() == 10
assert get_public_api_base_url() is None
assert get_s2s_api_base_url() is None
def test_env_overrides(self, monkeypatch):
monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_PROJECT_ID", " demo ")
monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_TOPIC_PREFIX", " mail-topic ")
monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_SUBSCRIPTION_PREFIX", " mail-sub ")
monkeypatch.setenv(
"XAGENT_GMAIL_PUBSUB_PUSH_SERVICE_ACCOUNT",
" [email protected] ",
)
monkeypatch.setenv("XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS", "3")
monkeypatch.setenv("XAGENT_PUBLIC_API_BASE_URL", " https://api.example.com/ ")
monkeypatch.setenv(
"XAGENT_S2S_API_BASE_URL", " https://sg-origin.example.com/ "
)
assert get_gmail_pubsub_project_id() == "demo"
assert get_gmail_pubsub_topic_prefix() == "mail-topic"
assert get_gmail_pubsub_subscription_prefix() == "mail-sub"
assert (
get_gmail_pubsub_push_service_account()
== "[email protected]"
)
assert get_gmail_registration_timeout_seconds() == 3
assert get_public_api_base_url() == "https://api.example.com"
assert get_s2s_api_base_url() == "https://sg-origin.example.com"
def test_s2s_base_falls_back_to_public_api_base(self, monkeypatch):
monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)
monkeypatch.setenv(
"XAGENT_PUBLIC_API_BASE_URL", " https://api.example.com/base/ "
)
assert get_s2s_api_base_url() == "https://api.example.com/base"
@pytest.mark.parametrize(
"value",
[
"api.example.com",
"ftp://api.example.com",
"https:///missing-host",
],
)
def test_s2s_base_rejects_invalid_http_urls(self, monkeypatch, value) -> None:
monkeypatch.setenv("XAGENT_S2S_API_BASE_URL", value)
with pytest.raises(ValueError, match="XAGENT_S2S_API_BASE_URL"):
get_s2s_api_base_url()
@pytest.mark.parametrize(
"value",
[
"https://api.example.com/base?region=sg",
"https://api.example.com/base#callbacks",
],
)
def test_s2s_base_rejects_query_and_fragment(self, monkeypatch, value) -> None:
monkeypatch.setenv("XAGENT_S2S_API_BASE_URL", value)
with pytest.raises(ValueError, match="XAGENT_S2S_API_BASE_URL"):
get_s2s_api_base_url()
def test_s2s_base_validates_public_api_fallback(self, monkeypatch) -> None:
monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)
monkeypatch.setenv(
"XAGENT_PUBLIC_API_BASE_URL",
"https://api.example.com?region=sg",
)
with pytest.raises(ValueError, match="XAGENT_PUBLIC_API_BASE_URL"):
get_s2s_api_base_url()
def test_gmail_callback_validates_legacy_fallback(self, monkeypatch) -> None:
monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)
monkeypatch.setenv(
"XAGENT_TRIGGER_CALLBACK_BASE_URL",
"https://legacy-callback.example.com#gmail",
)
resolver = getattr(config, "get_gmail_callback_base_url", lambda: None)
with pytest.raises(ValueError, match="XAGENT_TRIGGER_CALLBACK_BASE_URL"):
resolver()
def test_gmail_callback_preserves_legacy_base_url_fallback(self, monkeypatch):
monkeypatch.delenv("XAGENT_S2S_API_BASE_URL", raising=False)
monkeypatch.setenv(
"XAGENT_TRIGGER_CALLBACK_BASE_URL",
" https://legacy-callback.example.com/ ",
)
monkeypatch.setenv("XAGENT_PUBLIC_API_BASE_URL", "https://api.example.com")
assert (
getattr(config, "TRIGGER_CALLBACK_BASE_URL", None)
== "XAGENT_TRIGGER_CALLBACK_BASE_URL"
)
resolver = getattr(config, "get_gmail_callback_base_url", lambda: None)
assert resolver() == "https://legacy-callback.example.com"
assert get_s2s_api_base_url() == "https://api.example.com"
def test_invalid_timeout_uses_default(self, monkeypatch):
monkeypatch.setenv("XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS", "0")
assert get_gmail_registration_timeout_seconds() == 10
monkeypatch.setenv("XAGENT_GMAIL_REGISTRATION_TIMEOUT_SECONDS", "not-a-number")
assert get_gmail_registration_timeout_seconds() == 10
def test_pubsub_transport_defaults_to_grpc(self, monkeypatch):
from xagent.config import get_gmail_pubsub_transport
monkeypatch.delenv("XAGENT_GMAIL_PUBSUB_TRANSPORT", raising=False)
assert get_gmail_pubsub_transport() == "grpc"
monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_TRANSPORT", " REST ")
assert get_gmail_pubsub_transport() == "rest"
monkeypatch.setenv("XAGENT_GMAIL_PUBSUB_TRANSPORT", "carrier-pigeon")
assert get_gmail_pubsub_transport() == "grpc"
class TestTrustedProxyHopsConfig:
"""Config for proxy-aware remote IP derivation."""
def test_default_is_zero(self, monkeypatch):
from xagent.config import get_trusted_proxy_hops
monkeypatch.delenv("XAGENT_TRUSTED_PROXY_HOPS", raising=False)
assert get_trusted_proxy_hops() == 0
def test_env_override(self, monkeypatch):
from xagent.config import get_trusted_proxy_hops
monkeypatch.setenv("XAGENT_TRUSTED_PROXY_HOPS", "2")
assert get_trusted_proxy_hops() == 2
def test_invalid_value_falls_back_to_zero(self, monkeypatch):
from xagent.config import get_trusted_proxy_hops
monkeypatch.setenv("XAGENT_TRUSTED_PROXY_HOPS", "not-a-number")
assert get_trusted_proxy_hops() == 0
monkeypatch.setenv("XAGENT_TRUSTED_PROXY_HOPS", "-1")
assert get_trusted_proxy_hops() == 0
class TestTriggerCallbackIpRateLimitConfig:
"""Config for the IP-wide callback rate ceiling."""
def test_default(self, monkeypatch):
from xagent.config import get_trigger_callback_ip_rate_limit
monkeypatch.delenv("XAGENT_TRIGGER_CALLBACK_IP_RATE_LIMIT", raising=False)
assert get_trigger_callback_ip_rate_limit() == "600/minute"
def test_env_override(self, monkeypatch):
from xagent.config import get_trigger_callback_ip_rate_limit
monkeypatch.setenv("XAGENT_TRIGGER_CALLBACK_IP_RATE_LIMIT", "50/second")
assert get_trigger_callback_ip_rate_limit() == "50/second"
class TestGetSandboxIdleTtl:
"""Test get_sandbox_idle_ttl() function."""
def test_no_env_var_disables_reclamation(self, monkeypatch):
monkeypatch.delenv(SANDBOX_IDLE_TTL, raising=False)
assert get_sandbox_idle_ttl() is None
def test_blank_env_var_disables_reclamation(self, monkeypatch):
monkeypatch.setenv(SANDBOX_IDLE_TTL, " ")
assert get_sandbox_idle_ttl() is None
def test_valid_ttl_seconds(self, monkeypatch):
monkeypatch.setenv(SANDBOX_IDLE_TTL, "86400")
assert get_sandbox_idle_ttl() == 86400.0
def test_fractional_ttl_seconds(self, monkeypatch):
monkeypatch.setenv(SANDBOX_IDLE_TTL, "0.5")
assert get_sandbox_idle_ttl() == 0.5
def test_invalid_ttl_disables_reclamation(self, monkeypatch):
monkeypatch.setenv(SANDBOX_IDLE_TTL, "invalid")
assert get_sandbox_idle_ttl() is None
def test_non_positive_ttl_disables_reclamation(self, monkeypatch):
monkeypatch.setenv(SANDBOX_IDLE_TTL, "0")
assert get_sandbox_idle_ttl() is None
monkeypatch.setenv(SANDBOX_IDLE_TTL, "-60")
assert get_sandbox_idle_ttl() is None
def test_non_finite_ttl_disables_reclamation(self, monkeypatch):
for value in ("nan", "NaN", "inf", "-inf"):
monkeypatch.setenv(SANDBOX_IDLE_TTL, value)
assert get_sandbox_idle_ttl() is None
class TestGetSandboxSweepInterval:
"""Test get_sandbox_sweep_interval() function."""
def test_no_env_var_returns_default(self, monkeypatch):
monkeypatch.delenv(SANDBOX_SWEEP_INTERVAL, raising=False)
assert get_sandbox_sweep_interval() == 60.0
def test_valid_interval(self, monkeypatch):
monkeypatch.setenv(SANDBOX_SWEEP_INTERVAL, "5")
assert get_sandbox_sweep_interval() == 5.0
def test_invalid_interval_returns_default(self, monkeypatch):
monkeypatch.setenv(SANDBOX_SWEEP_INTERVAL, "invalid")
assert get_sandbox_sweep_interval() == 60.0
def test_non_positive_interval_returns_default(self, monkeypatch):
monkeypatch.setenv(SANDBOX_SWEEP_INTERVAL, "0")
assert get_sandbox_sweep_interval() == 60.0
def test_non_finite_interval_returns_default(self, monkeypatch):
for value in ("nan", "inf", "-inf"):
monkeypatch.setenv(SANDBOX_SWEEP_INTERVAL, value)
assert get_sandbox_sweep_interval() == 60.0
class TestGetSandboxMaxContainers:
"""Test get_sandbox_max_containers() function."""
def test_no_env_var_disables_cap(self, monkeypatch):
monkeypatch.delenv(SANDBOX_MAX_CONTAINERS, raising=False)
assert get_sandbox_max_containers() is None
def test_valid_cap(self, monkeypatch):
monkeypatch.setenv(SANDBOX_MAX_CONTAINERS, "20")
assert get_sandbox_max_containers() == 20
def test_invalid_cap_disables_cap(self, monkeypatch):
monkeypatch.setenv(SANDBOX_MAX_CONTAINERS, "invalid")
assert get_sandbox_max_containers() is None
def test_non_positive_cap_disables_cap(self, monkeypatch):
monkeypatch.setenv(SANDBOX_MAX_CONTAINERS, "0")
assert get_sandbox_max_containers() is None
monkeypatch.setenv(SANDBOX_MAX_CONTAINERS, "-5")
assert get_sandbox_max_containers() is None
class TestCheckpointGateStallWarningConfig:
"""Config for reporting a long-held exclusive checkpoint section."""
def test_defaults_to_30_seconds(self, monkeypatch):
from xagent.config import (
CHECKPOINT_GATE_STALL_WARNING_SECONDS,
get_checkpoint_gate_stall_warning_seconds,
)
monkeypatch.delenv(CHECKPOINT_GATE_STALL_WARNING_SECONDS, raising=False)
assert get_checkpoint_gate_stall_warning_seconds() == 30.0
def test_env_override(self, monkeypatch):
from xagent.config import (
CHECKPOINT_GATE_STALL_WARNING_SECONDS,
get_checkpoint_gate_stall_warning_seconds,
)
monkeypatch.setenv(CHECKPOINT_GATE_STALL_WARNING_SECONDS, "2.5")
assert get_checkpoint_gate_stall_warning_seconds() == 2.5
@pytest.mark.parametrize("value", ["abc", "0", "-1", "nan", "inf"])
def test_invalid_values_fall_back(self, monkeypatch, value):
from xagent.config import (
CHECKPOINT_GATE_STALL_WARNING_SECONDS,
get_checkpoint_gate_stall_warning_seconds,
)
monkeypatch.setenv(CHECKPOINT_GATE_STALL_WARNING_SECONDS, value)
assert get_checkpoint_gate_stall_warning_seconds() == 30.0
class TestCompactThresholdConfig:
"""Config for context-compaction threshold derivation."""
def test_ratio_defaults_to_075(self, monkeypatch):
from xagent.config import COMPACT_THRESHOLD_RATIO, get_compact_threshold_ratio
monkeypatch.delenv(COMPACT_THRESHOLD_RATIO, raising=False)
assert get_compact_threshold_ratio() == 0.75
def test_ratio_env_override(self, monkeypatch):
from xagent.config import COMPACT_THRESHOLD_RATIO, get_compact_threshold_ratio
monkeypatch.setenv(COMPACT_THRESHOLD_RATIO, "0.8")
assert get_compact_threshold_ratio() == 0.8
@pytest.mark.parametrize("value", ["abc", "0", "-0.5", "1.5", "0.0"])
def test_ratio_invalid_or_out_of_range_falls_back(self, monkeypatch, value):
from xagent.config import COMPACT_THRESHOLD_RATIO, get_compact_threshold_ratio
monkeypatch.setenv(COMPACT_THRESHOLD_RATIO, value)
assert get_compact_threshold_ratio() == 0.75
def test_default_defaults_to_32000(self, monkeypatch):
from xagent.config import (
COMPACT_THRESHOLD_DEFAULT,
get_compact_threshold_default,
)
monkeypatch.delenv(COMPACT_THRESHOLD_DEFAULT, raising=False)
assert get_compact_threshold_default() == 32000
def test_default_env_override(self, monkeypatch):
from xagent.config import (
COMPACT_THRESHOLD_DEFAULT,
get_compact_threshold_default,
)
monkeypatch.setenv(COMPACT_THRESHOLD_DEFAULT, "64000")
assert get_compact_threshold_default() == 64000
@pytest.mark.parametrize("value", ["abc", "0", "-1"])
def test_default_invalid_or_non_positive_falls_back(self, monkeypatch, value):
from xagent.config import (
COMPACT_THRESHOLD_DEFAULT,
get_compact_threshold_default,
)
monkeypatch.setenv(COMPACT_THRESHOLD_DEFAULT, value)
assert get_compact_threshold_default() == 32000
class TestUrlUserinfoRejectionIsScopedToDeepDoc:
"""Only the DeepDoc URL rejects embedded credentials.
The rejection guards a specific hazard: the remote client interpolates
``httpx.HTTPStatusError`` — which renders the URL unredacted — into an
exception the caller logs. Putting the check inside the shared
``_normalized_http_env_url`` would also apply it to
``PUBLIC_API_BASE_URL``/``S2S_API_BASE_URL``, whose call sites do not catch
``ValueError`` and depend on ``or``-chained fallbacks, so a pre-existing
(if ill-advised) config would start failing at runtime.
"""
def test_deepdoc_url_rejects_credentials(
self, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, "http://user:pw@gpu-host:9997")
with pytest.raises(ValueError, match="credentials embedded"):
get_deepdoc_xinference_url()
def test_deepdoc_url_without_credentials_is_accepted(
self, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.setenv(DEEPDOC_XINFERENCE_URL, "http://gpu-host:9997/base")
assert get_deepdoc_xinference_url() == "http://gpu-host:9997/base"
def test_shared_helper_consumers_keep_working(
self, monkeypatch: pytest.MonkeyPatch
) -> None:
"""The other consumers of the shared helper must be unaffected."""
monkeypatch.setenv(PUBLIC_API_BASE_URL, "http://user:[email protected]")
monkeypatch.delenv(S2S_API_BASE_URL, raising=False)
assert get_public_api_base_url() == "http://user:[email protected]"
assert get_s2s_api_base_url() == "http://user:[email protected]"
def test_inline_file_delivery_budget(monkeypatch, caplog):
monkeypatch.delenv(config.INLINE_FILE_DELIVERY_MAX_BYTES, raising=False)
assert config.get_inline_file_delivery_max_bytes() == 8 * 1024 * 1024
for value in ("0", "1024"):
monkeypatch.setenv(config.INLINE_FILE_DELIVERY_MAX_BYTES, value)
assert config.get_inline_file_delivery_max_bytes() == int(value)
for value in ("-1", "invalid", ""):
monkeypatch.setenv(config.INLINE_FILE_DELIVERY_MAX_BYTES, value)
caplog.clear()
assert config.get_inline_file_delivery_max_bytes() == 0
assert "Invalid XAGENT_INLINE_FILE_DELIVERY_MAX_BYTES" in caplog.text
_OTEL_ENV_VARS = (
"XAGENT_RUNTIME_TELEMETRY_ENABLED",
"XAGENT_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
"XAGENT_OTEL_EXPORT_INTERVAL_MILLISECONDS",
"XAGENT_OTEL_SERVICE_NAME",
"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
"OTEL_EXPORTER_OTLP_ENDPOINT",
"OTEL_METRIC_EXPORT_INTERVAL",
"OTEL_SERVICE_NAME",
)
def _clear_otel_env(monkeypatch: pytest.MonkeyPatch) -> None:
for env_var in _OTEL_ENV_VARS:
monkeypatch.delenv(env_var, raising=False)
def test_runtime_telemetry_defaults_to_disabled(
monkeypatch: pytest.MonkeyPatch,
) -> None:
_clear_otel_env(monkeypatch)
assert config.get_otel_metrics_endpoint() is None
assert config.get_runtime_telemetry_enabled() is False
assert config.get_otel_export_interval_milliseconds() == 10_000
assert config.get_otel_service_name() == "xagent"
def test_xagent_otel_endpoint_enables_export_and_explicit_false_disables_it(
monkeypatch: pytest.MonkeyPatch,
) -> None:
_clear_otel_env(monkeypatch)
monkeypatch.setenv(
"XAGENT_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
" http://collector:4318/v1/metrics/ ",
)
assert config.get_otel_metrics_endpoint() == "http://collector:4318/v1/metrics"
assert config.get_runtime_telemetry_enabled() is True
monkeypatch.setenv("XAGENT_RUNTIME_TELEMETRY_ENABLED", "false")
assert config.get_runtime_telemetry_enabled() is False
def test_standard_otel_fallbacks_and_xagent_precedence(
monkeypatch: pytest.MonkeyPatch,
) -> None:
_clear_otel_env(monkeypatch)
monkeypatch.setenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://standard:4318/")
monkeypatch.setenv("OTEL_METRIC_EXPORT_INTERVAL", "30000")
monkeypatch.setenv("OTEL_SERVICE_NAME", "standard-xagent")
assert config.get_otel_metrics_endpoint() == "http://standard:4318/v1/metrics"
assert config.get_otel_export_interval_milliseconds() == 30_000
assert config.get_otel_service_name() == "standard-xagent"
monkeypatch.setenv(
"XAGENT_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
"http://xagent:4318/v1/metrics",
)
monkeypatch.setenv("XAGENT_OTEL_EXPORT_INTERVAL_MILLISECONDS", "5000")
monkeypatch.setenv("XAGENT_OTEL_SERVICE_NAME", "xagent-override")
assert config.get_otel_metrics_endpoint() == "http://xagent:4318/v1/metrics"
assert config.get_otel_export_interval_milliseconds() == 5_000
assert config.get_otel_service_name() == "xagent-override"
def test_toby_personal_stdio_is_disabled_by_default(monkeypatch):
monkeypatch.delenv(config.TOBY_PERSONAL_STDIO_ENABLED, raising=False)
assert config.get_toby_personal_stdio_enabled() is False
def test_trace_database_defaults_and_opt_in(monkeypatch):
monkeypatch.delenv(config.ASYNC_TRACE_DB_ENABLED, raising=False)
monkeypatch.delenv(config.TRACE_DB_MAX_INFLIGHT, raising=False)
assert config.get_async_trace_db_enabled() is True
assert config.get_trace_db_max_inflight() == 4
monkeypatch.setenv(config.ASYNC_TRACE_DB_ENABLED, "true")
monkeypatch.setenv(config.TRACE_DB_MAX_INFLIGHT, "8")
assert config.get_async_trace_db_enabled() is True
assert config.get_trace_db_max_inflight() == 8
@pytest.mark.parametrize("value", ["0", "-1", "invalid"])
def test_trace_database_invalid_admission_limit_falls_back(monkeypatch, value):
monkeypatch.setenv(config.TRACE_DB_MAX_INFLIGHT, value)
assert config.get_trace_db_max_inflight() == 4
def test_db_write_retry_defaults(monkeypatch):
monkeypatch.delenv(config.DB_WRITE_RETRY_ATTEMPTS, raising=False)
monkeypatch.delenv(config.DB_WRITE_RETRY_BASE_DELAY_MS, raising=False)
monkeypatch.delenv(config.DB_WRITE_RETRY_MAX_DELAY_MS, raising=False)
assert config.get_db_write_retry_attempts() == 3
assert config.get_db_write_retry_base_delay_ms() == 50
assert config.get_db_write_retry_max_delay_ms() == 1000
def test_db_write_retry_overrides(monkeypatch):
monkeypatch.setenv(config.DB_WRITE_RETRY_ATTEMPTS, "5")
monkeypatch.setenv(config.DB_WRITE_RETRY_BASE_DELAY_MS, "10")
monkeypatch.setenv(config.DB_WRITE_RETRY_MAX_DELAY_MS, "250")
assert config.get_db_write_retry_attempts() == 5
assert config.get_db_write_retry_base_delay_ms() == 10
assert config.get_db_write_retry_max_delay_ms() == 250
def test_db_write_retry_zero_delays_are_allowed(monkeypatch):
monkeypatch.setenv(config.DB_WRITE_RETRY_BASE_DELAY_MS, "0")
monkeypatch.setenv(config.DB_WRITE_RETRY_MAX_DELAY_MS, "0")
assert config.get_db_write_retry_base_delay_ms() == 0
assert config.get_db_write_retry_max_delay_ms() == 0
def test_db_write_retry_one_attempt_disables_retries(monkeypatch):
monkeypatch.setenv(config.DB_WRITE_RETRY_ATTEMPTS, "1")
assert config.get_db_write_retry_attempts() == 1
@pytest.mark.parametrize("value", ["0", "-1", "abc"])
def test_db_write_retry_invalid_attempts_fall_back(monkeypatch, value):
monkeypatch.setenv(config.DB_WRITE_RETRY_ATTEMPTS, value)
assert config.get_db_write_retry_attempts() == 3
@pytest.mark.parametrize("value", ["-1", "abc"])
def test_db_write_retry_invalid_delays_fall_back(monkeypatch, value):
monkeypatch.setenv(config.DB_WRITE_RETRY_BASE_DELAY_MS, value)
monkeypatch.setenv(config.DB_WRITE_RETRY_MAX_DELAY_MS, value)
assert config.get_db_write_retry_base_delay_ms() == 50
assert config.get_db_write_retry_max_delay_ms() == 1000
@pytest.mark.parametrize("value", ["1", "true", "YES", "on"])
def test_toby_personal_stdio_explicit_opt_in(monkeypatch, value):
monkeypatch.setenv(config.TOBY_PERSONAL_STDIO_ENABLED, value)
assert config.get_toby_personal_stdio_enabled() is True
@pytest.mark.parametrize(
"value,expected",
[
(None, False),
("", False),
("0", False),
("off", False),
("1", True),
("True", True),
],
)
def test_standby_enabled_parses_boolean(monkeypatch, value, expected):
if value is None:
monkeypatch.delenv(config.STANDBY, raising=False)
else:
monkeypatch.setenv(config.STANDBY, value)
assert config.get_standby_enabled() is expected
def test_standby_enabled_rejects_a_typo(monkeypatch):
monkeypatch.setenv(config.STANDBY, "maybe")
with pytest.raises(ValueError, match="XAGENT_STANDBY"):
config.get_standby_enabled()
@pytest.mark.parametrize("value,expected", [("true", True), ("false", False)])
def test_shared_task_execution_explicit_setting_wins(monkeypatch, value, expected):
monkeypatch.delenv(config.SHARED_TASK_EXECUTION_ENABLED, raising=False)
monkeypatch.setenv(config.WORKER_COUNT, "4")
monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, value)
assert config.get_shared_task_execution_enabled() is expected
@pytest.mark.parametrize("value", ["", " "])
@pytest.mark.parametrize(
"role,worker_count",
[("combined", "4"), ("web", None), ("worker", None)],
)
def test_blank_shared_task_execution_setting_uses_topology(
monkeypatch, value, role, worker_count
):
monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, value)
monkeypatch.setenv(config.TASK_EXECUTION_ROLE, role)
monkeypatch.delenv(config.WORKER_COUNT, raising=False)
if worker_count is not None:
monkeypatch.setenv(config.WORKER_COUNT, worker_count)
assert config.get_shared_task_execution_enabled() is True
@pytest.mark.parametrize(
"role,worker_count,expected",
[
("combined", None, False),
("combined", "4", True),
("web", None, True),
("worker", None, True),
],
)
def test_shared_task_execution_default_follows_topology(
monkeypatch, role, worker_count, expected
):
monkeypatch.delenv(config.SHARED_TASK_EXECUTION_ENABLED, raising=False)
monkeypatch.setenv(config.TASK_EXECUTION_ROLE, role)
monkeypatch.delenv(config.WORKER_COUNT, raising=False)
if worker_count is not None:
monkeypatch.setenv(config.WORKER_COUNT, worker_count)
assert config.get_shared_task_execution_enabled() is expected
def test_default_task_execution_host_configuration_is_self_contained(monkeypatch):
monkeypatch.delenv(config.SHARED_TASK_EXECUTION_ENABLED, raising=False)
monkeypatch.delenv(config.TASK_EXECUTION_ROLE, raising=False)
monkeypatch.delenv(config.WORKER_COUNT, raising=False)
monkeypatch.delenv(config.REDIS_URL, raising=False)
monkeypatch.delenv(config.ENCRYPTION_KEY, raising=False)
assert config.get_shared_task_execution_enabled() is False
assert config.get_task_execution_role() == "combined"
assert config.get_channel_ingress_enabled() is False
config.validate_task_execution_host_config()
@pytest.mark.parametrize("value", ["0", "-1", "invalid"])
def test_local_host_rejects_invalid_runtime_secret_ttl_at_startup(monkeypatch, value):
monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, "false")
monkeypatch.setenv(config.TASK_EXECUTION_ROLE, "combined")
monkeypatch.setenv(config.TASK_RUNTIME_SECRETS_TTL_SECONDS, value)
with pytest.raises(ValueError):
config.validate_task_execution_host_config()
@pytest.mark.parametrize("value", ["", " ", "deployment/channel"])
def test_task_event_channel_prefix_rejects_invalid_namespace(monkeypatch, value):
monkeypatch.setenv(config.TASK_EVENT_CHANNEL_PREFIX, value)
with pytest.raises(ValueError, match="channel prefix"):
config.get_task_event_channel_prefix()
def test_task_event_channel_prefix_default_and_override(monkeypatch):
monkeypatch.delenv(config.TASK_EVENT_CHANNEL_PREFIX, raising=False)
assert config.get_task_event_channel_prefix() == "xagent:task-events:v1"
monkeypatch.setenv(config.TASK_EVENT_CHANNEL_PREFIX, "xagent:staging:v1")
assert config.get_task_event_channel_prefix() == "xagent:staging:v1"
@pytest.mark.parametrize("key", [None, ""])
def test_task_runtime_secrets_reject_unconfigured_key(monkeypatch, key):
monkeypatch.delenv(config.ENCRYPTION_KEY, raising=False)
if key is not None:
monkeypatch.setenv(config.ENCRYPTION_KEY, key)
assert config.get_task_runtime_secrets_encryption_key() is None
def test_task_runtime_secrets_use_explicit_fallback_key(monkeypatch):
monkeypatch.setenv(config.ENCRYPTION_KEY, config.DEV_FALLBACK_ENCRYPTION_KEY)
assert (
config.get_task_runtime_secrets_encryption_key()
== config.DEV_FALLBACK_ENCRYPTION_KEY
)
def test_task_runtime_secrets_use_explicit_key(monkeypatch):
from cryptography.fernet import Fernet
key = Fernet.generate_key().decode()
monkeypatch.setenv(config.ENCRYPTION_KEY, key)
assert config.get_task_runtime_secrets_encryption_key() == key
@pytest.mark.parametrize(
"value,expected", [(None, 30), ("12", 12), ("0", 30), ("-1", 30), ("bad", 30)]
)
def test_task_reply_wait_timeout(value, expected, monkeypatch):
from xagent.config import (
get_input_review_timeout_seconds,
get_task_reply_wait_timeout_seconds,
)
monkeypatch.delenv("XAGENT_TASK_REPLY_WAIT_TIMEOUT_SECONDS", raising=False)
if value is not None:
monkeypatch.setenv("XAGENT_TASK_REPLY_WAIT_TIMEOUT_SECONDS", value)
assert get_task_reply_wait_timeout_seconds() == expected
assert get_input_review_timeout_seconds() == pytest.approx(min(20, expected * 0.8))
assert get_input_review_timeout_seconds() < expected
@pytest.mark.parametrize(
"shared,role,override,expected",
[
(False, "combined", None, True),
(True, "combined", None, False),
(True, "web", "true", True),
(True, "web", "false", False),
(True, "worker", "true", False),
],
)
def test_designated_channel_ingress(monkeypatch, shared, role, override, expected):
monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, str(shared).lower())
monkeypatch.setenv(config.TASK_EXECUTION_ROLE, role)
monkeypatch.delenv(config.CHANNEL_INGRESS_ENABLED, raising=False)
if override is not None:
monkeypatch.setenv(config.CHANNEL_INGRESS_ENABLED, override)
assert config.get_channel_ingress_enabled() is expected
@pytest.mark.parametrize("role", ["combined", "web", "worker"])
def test_shared_host_configuration(monkeypatch, role):
from cryptography.fernet import Fernet
monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, "true")
monkeypatch.setenv(config.TASK_EXECUTION_ROLE, role)
monkeypatch.setenv(config.REDIS_URL, "redis://localhost:6379/0")
monkeypatch.setenv(config.ENCRYPTION_KEY, Fernet.generate_key().decode())
config.validate_task_execution_host_config()
monkeypatch.setenv(config.ENCRYPTION_KEY, config.DEV_FALLBACK_ENCRYPTION_KEY)
config.validate_task_execution_host_config()
monkeypatch.delenv(config.ENCRYPTION_KEY)
with pytest.raises(ValueError, match="private common ENCRYPTION_KEY"):
config.validate_task_execution_host_config()
monkeypatch.setenv(config.SHARED_TASK_EXECUTION_ENABLED, "false")
if role == "combined":
config.validate_task_execution_host_config()
else:
with pytest.raises(ValueError, match="requires"):
config.validate_task_execution_host_config()
def test_unknown_task_execution_role_rejected(monkeypatch):
monkeypatch.setenv(config.TASK_EXECUTION_ROLE, "other")
with pytest.raises(ValueError, match="combined, web or worker"):
config.validate_task_execution_host_config()
@pytest.mark.parametrize(
"value,expected", [(None, None), ("", None), ("1", 1), ("4", 4)]
)
def test_worker_count_optional_positive_integer(monkeypatch, value, expected):
monkeypatch.delenv(config.WORKER_COUNT, raising=False)
if value is not None:
monkeypatch.setenv(config.WORKER_COUNT, value)
assert config.get_worker_count() == expected
@pytest.mark.parametrize("value", ["0", "-1", "1.5", "invalid"])
def test_worker_count_rejects_invalid_values(monkeypatch, value):
monkeypatch.setenv(config.WORKER_COUNT, value)
with pytest.raises(
ValueError, match="XAGENT_WORKER_COUNT must be a positive integer"
):
config.get_worker_count()
# ---------------------------------------------------------------------------
# Conversation data retention (#2563).
#
# Two properties run through these cases, and every test here is one of them:
# a period that cannot be read disables the leg it configures rather than
# falling back to a number of days, and a switch that cannot be read resolves
# to whichever side deletes nothing.
# ---------------------------------------------------------------------------
@pytest.fixture
def no_retention_env(monkeypatch):
"""Clear every retention variable, so no case inherits another's state.
Driven from ``config.RETENTION_ENV_VARS`` rather than a list written here,
so a setting added without a test cannot silently inherit whatever the
surrounding suite left behind.
"""
for name in config.RETENTION_ENV_VARS:
monkeypatch.delenv(name, raising=False)
return monkeypatch
def _warnings(caplog) -> list[str]:
return [record.getMessage() for record in caplog.records]
@pytest.mark.parametrize(
"value,expected",
[
(None, None),
("", None),
(" ", None),
("0", None),
("365", 365),
("1", 1),
(str(config.MAX_RETENTION_DAYS), config.MAX_RETENTION_DAYS),
# Every one of these is a mistake, and must disable rather than fall
# back to some working number of days.
("-1", None),
("90d", None),
("ninety", None),
("9.5", None),
# An operator pasting a date. Parses as an integer, and no date can
# express it -- `now - timedelta(days=20260923)` raises OverflowError,
# which a consumer would hit on every use.
("20260923", None),
("1000000000", None),
(str(config.MAX_RETENTION_DAYS + 1), None),
],
)
def test_conversation_retention_days(no_retention_env, value, expected):
if value is not None:
no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, value)
assert config.get_conversation_retention_days() == expected
def test_an_accepted_period_can_always_be_expressed_as_a_date(no_retention_env):
"""The bound is only correct if everything under it actually works.
Pinned against the arithmetic it protects rather than against a number
written twice: ``retention_cutoff`` is what raises, so it decides whether
``MAX_RETENTION_DAYS`` is set right. This caught the first value written.
"""
from datetime import datetime, timezone
from xagent.web.services.task_retention import retention_cutoff
no_retention_env.setenv(
config.CONVERSATION_RETENTION_DAYS, str(config.MAX_RETENTION_DAYS)
)
parsed = config.get_conversation_retention_days()
assert parsed == config.MAX_RETENTION_DAYS
assert retention_cutoff(now=datetime.now(timezone.utc), days=parsed) is not None
@pytest.mark.parametrize(
"raw,expected",
[
# Every spelling of zero inherits the conversation period, because "0"
# means "same as the conversation period" and ``int`` is the authority
# on what zero is. Comparing the raw string against "0" instead
# disagreed with ``int`` about these, and silently disabled traces.
("0", 365),
(" 0 ", 365),
("00", 365),
("-0", 365),
# Absent, likewise inherits.
("", 365),
(" ", 365),
("90", 90),
# Longer than the conversation period: accepted, and inert.
("3650", 3650),
# Unusable: disables the leg being configured rather than inheriting.
("0.0", None),
("90d", None),
("-5", None),
("800000", None),
],
)
def test_trace_period_reads_every_spelling_the_way_int_does(
no_retention_env, raw, expected
):
no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, "365")
no_retention_env.setenv(config.TRACE_RETENTION_DAYS, raw)
assert config.get_trace_retention_days() == expected
def test_trace_alone_expires_traces_while_conversations_are_kept(no_retention_env):
"""A supported shape, not an accident: traces are most of the bytes."""
no_retention_env.setenv(config.TRACE_RETENTION_DAYS, "90")
assert config.get_trace_retention_days() == 90
assert config.get_conversation_retention_days() is None
def test_an_unusable_conversation_period_does_not_reach_the_trace_leg(
no_retention_env,
):
"""Each leg is disabled on its own; neither failure contaminates the other."""
no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, "90d")
assert config.get_conversation_retention_days() is None
assert config.get_trace_retention_days() is None
no_retention_env.setenv(config.TRACE_RETENTION_DAYS, "30")
assert config.get_trace_retention_days() == 30
def test_both_periods_zero_disables_everything(no_retention_env):
no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, "0")
no_retention_env.setenv(config.TRACE_RETENTION_DAYS, "0")
assert config.get_conversation_retention_days() is None
assert config.get_trace_retention_days() is None
@pytest.mark.parametrize("value", ["-1", "90d", str(config.MAX_RETENTION_DAYS + 1)])
def test_an_unusable_period_warns(no_retention_env, caplog, value):
no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, value)
with caplog.at_level(logging.WARNING, logger="xagent.config"):
config.get_conversation_retention_days()
assert any(config.CONVERSATION_RETENTION_DAYS in m for m in _warnings(caplog))
@pytest.mark.parametrize("value", ["0", "", " ", "365"])
def test_a_usable_or_absent_period_does_not_warn(no_retention_env, caplog, value):
"""Zero and blank are documented spellings, not mistakes."""
no_retention_env.setenv(config.CONVERSATION_RETENTION_DAYS, value)
with caplog.at_level(logging.WARNING, logger="xagent.config"):
config.get_conversation_retention_days()
assert _warnings(caplog) == []
@pytest.mark.parametrize(
"value,expected",
[
(None, False),
("true", True),
("TRUE", True),
(" yes ", True),
("1", True),
("y", True),
("false", False),
("n", False),
("off", False),
# Unrecognised: this is the setting an operator reaches for before a
# first real run, so the failure direction is "reported, not deleted".
("enabled", True),
("maybe", True),
# Blank is unset, not a typo: a compose file interpolating an unset
# shell variable passes an empty string, which says nothing.
("", False),
(" ", False),
],
)
def test_dry_run_resolves_an_unrecognised_value_to_dry(
no_retention_env, value, expected
):
if value is not None:
no_retention_env.setenv(config.RETENTION_DRY_RUN, value)
assert config.get_retention_dry_run() is expected
@pytest.mark.parametrize(
"value,expected",
[
(None, True),
("true", True),
("y", True),
(" ON ", True),
("false", False),
("off", False),
("n", False),
# Unrecognised resolves to "stopped": for a kill switch, refusing to
# act is the side that cannot delete anything.
("enabled", False),
("t", False),
# Blank is unset, so it must not read as a deliberate stop.
("", True),
(" ", True),
],
)
def test_kill_switch_resolves_an_unrecognised_value_to_stopped(
no_retention_env, value, expected
):
if value is not None:
no_retention_env.setenv(config.RETENTION_ENABLED, value)
assert config.get_retention_enabled() is expected
@pytest.mark.parametrize("name", [config.RETENTION_DRY_RUN, config.RETENTION_ENABLED])
def test_an_unrecognised_switch_warns(no_retention_env, caplog, name):
"""Unlike a period, there is no legitimate spelling a switch rejects."""
no_retention_env.setenv(name, "enabled")
with caplog.at_level(logging.WARNING, logger="xagent.config"):
config.get_retention_dry_run()
config.get_retention_enabled()
assert any(name in message for message in _warnings(caplog))
@pytest.mark.parametrize("name", [config.RETENTION_DRY_RUN, config.RETENTION_ENABLED])
@pytest.mark.parametrize("value", ["", " ", "true", "no"])
def test_a_readable_or_blank_switch_does_not_warn(
no_retention_env, caplog, name, value
):
no_retention_env.setenv(name, value)
with caplog.at_level(logging.WARNING, logger="xagent.config"):
config.get_retention_dry_run()
config.get_retention_enabled()
assert _warnings(caplog) == []
def test_blank_is_unset_for_every_setting(no_retention_env):
"""All four parsers must agree about what an empty value means.
They did not at first: the periods read blank as unset while the switches
read it as an unrecognised value and the batch size read it as invalid.
The visible consequence was a compose file interpolating an unset shell
variable turning into a deliberate stop, warning on every read.
"""
for name in config.RETENTION_ENV_VARS:
no_retention_env.setenv(name, "")
assert config.get_conversation_retention_days() is None
assert config.get_trace_retention_days() is None
assert config.get_retention_enabled() is True
assert config.get_retention_dry_run() is False
assert config.get_retention_batch_size() == 100
assert config.get_retention_sweep_interval_seconds() == 86400.0
assert config.get_retention_batch_pause_seconds() == 5.0
@pytest.mark.parametrize(
"value,expected", [(None, 100), ("250", 250), ("0", 100), ("nope", 100), ("", 100)]
)
def test_retention_batch_size(no_retention_env, value, expected):
if value is not None:
no_retention_env.setenv(config.RETENTION_BATCH_SIZE, value)
assert config.get_retention_batch_size() == expected
@pytest.mark.parametrize(
"value,expected",
[(None, 86400.0), ("60", 60.0), ("0", 86400.0), ("-1", 86400.0), ("x", 86400.0)],
)
def test_retention_sweep_interval(no_retention_env, value, expected):
if value is not None:
no_retention_env.setenv(config.RETENTION_SWEEP_INTERVAL_SECONDS, value)
assert config.get_retention_sweep_interval_seconds() == expected
@pytest.mark.parametrize(
"value,expected", [(None, 5.0), ("0.5", 0.5), ("0", 5.0), ("nope", 5.0)]
)
def test_retention_batch_pause(no_retention_env, value, expected):
if value is not None:
no_retention_env.setenv(config.RETENTION_BATCH_PAUSE_SECONDS, value)
assert config.get_retention_batch_pause_seconds() == expected
def test_no_module_assigns_a_retention_environment_variable():
"""Pins the claim the section comment makes about needing a restart.
That claim holds only while nothing writes these names into the
environment, and other code in this repository does write ``os.environ``
(``worker_pool`` sets the execution role for the processes it spawns), so
it has to be checked rather than assumed.
The scan is a heuristic and says so: it covers assignment, ``update``,
``setdefault``, ``putenv`` and ``load_dotenv(override=True)``, spelled
through either the literal name or the constant. A computed key would slip
past it. It is worth having anyway -- every way this claim has actually
been broken in review is on the list -- but it is a tripwire, not a proof.
"""
import re
from pathlib import Path as _Path
source_root = _Path(config.__file__).parent
names = "|".join(
[re.escape(name) for name in config.RETENTION_ENV_VARS]
+ [
re.escape(name.removeprefix("XAGENT_"))
for name in config.RETENTION_ENV_VARS
]
)
quoted = rf"""["']?({names})["']?"""
pattern = re.compile(
"|".join(
[
rf"environ\[\s*{quoted}\s*\]\s*=",
rf"environ\.setdefault\(\s*{quoted}",
rf"putenv\(\s*{quoted}",
rf"environ\.update\([^)]*{quoted}",
r"load_dotenv\([^)]*override\s*=\s*True",
]
)
)
offenders = sorted(
str(path.relative_to(source_root))
for path in source_root.rglob("*.py")
if pattern.search(path.read_text(encoding="utf-8", errors="ignore"))
)
assert offenders == [], (
"these modules can change a retention variable after start-up, which "
f"breaks the documented 'takes a restart' guarantee: {offenders}"
)
_AUTO_RESUME_INT_SETTINGS = [
("TASK_AUTO_RESUME_POLL_SECONDS", "get_task_auto_resume_poll_seconds", 5),
("TASK_AUTO_RESUME_MAX_PER_TICK", "get_task_auto_resume_max_per_tick", 20),
("TASK_AUTO_RESUME_MAX_INFLIGHT", "get_task_auto_resume_max_inflight", 50),
("TASK_AUTO_RESUME_WINDOW_SECONDS", "get_task_auto_resume_window_seconds", 86400),
(
"TASK_AUTO_RESUME_CHANNEL_WINDOW_SECONDS",
"get_task_auto_resume_channel_window_seconds",
1800,
),
(
"TASK_AUTO_RESUME_MAX_TOTAL_PER_RUN",
"get_task_auto_resume_max_total_per_run",
20,
),
(
"TASK_AUTO_RESUME_SHORT_INITIAL_BACKOFF_SECONDS",
"get_task_auto_resume_short_initial_backoff_seconds",
10,
),
(
"TASK_AUTO_RESUME_SHORT_MAX_NO_PROGRESS",
"get_task_auto_resume_short_max_no_progress",
3,
),
(
"TASK_AUTO_RESUME_LLM_INITIAL_BACKOFF_SECONDS",
"get_task_auto_resume_llm_initial_backoff_seconds",
60,
),
(
"TASK_AUTO_RESUME_LLM_MAX_BACKOFF_SECONDS",
"get_task_auto_resume_llm_max_backoff_seconds",
900,
),
(
"TASK_AUTO_RESUME_LLM_MAX_ELAPSED_SECONDS",
"get_task_auto_resume_llm_max_elapsed_seconds",
7200,
),
(
"TASK_AUTO_RESUME_MODEL_OUTPUT_MAX_NO_PROGRESS",
"get_task_auto_resume_model_output_max_no_progress",
2,
),
]
_AUTO_RESUME_BOOL_SETTINGS = [
("TASK_INFRA_FAILURE_PAUSE_ENABLED", "get_task_infra_failure_pause_enabled", True),
("TASK_AUTO_RESUME_ENABLED", "get_task_auto_resume_enabled", True),
]
class TestTaskAutoRecoveryConfig:
@pytest.mark.parametrize("const,getter,default", _AUTO_RESUME_INT_SETTINGS)
def test_int_setting_defaults_overrides_and_invalid(
self, monkeypatch, caplog, const, getter, default
):
env_var = getattr(config, const)
assert env_var == f"XAGENT_{const}"
read = getattr(config, getter)
monkeypatch.delenv(env_var, raising=False)
assert read() == default
monkeypatch.setenv(env_var, "7")
assert read() == 7
for invalid in ("", "abc", "0", "-3", "1.5"):
monkeypatch.setenv(env_var, invalid)
caplog.clear()
with caplog.at_level(logging.WARNING, logger="xagent.config"):
assert read() == default
assert env_var in caplog.text
@pytest.mark.parametrize("const,getter,default", _AUTO_RESUME_BOOL_SETTINGS)
def test_bool_setting_defaults_overrides_and_invalid(
self, monkeypatch, caplog, const, getter, default
):
env_var = getattr(config, const)
assert env_var == f"XAGENT_{const}"
read = getattr(config, getter)
monkeypatch.delenv(config.TASK_AUTO_RESUME_ENABLED, raising=False)
monkeypatch.delenv(env_var, raising=False)
assert read() is default
for falsy in ("false", "0", "no", "off", " FALSE "):
monkeypatch.setenv(env_var, falsy)
assert read() is False
for truthy in ("true", "1", "yes", "on", "True"):
monkeypatch.setenv(env_var, truthy)
assert read() is True
for blank in ("", " "):
monkeypatch.setenv(env_var, blank)
caplog.clear()
with caplog.at_level(logging.WARNING, logger="xagent.config"):
assert read() is default
assert env_var not in caplog.text
for invalid in ("maybe", "2"):
monkeypatch.setenv(env_var, invalid)
caplog.clear()
with caplog.at_level(logging.WARNING, logger="xagent.config"):
assert read() is default
assert env_var in caplog.text
@pytest.mark.parametrize("auto_resume", [True, False])
def test_infra_failure_pause_follows_auto_resume_unless_set(
self, monkeypatch, auto_resume
):
monkeypatch.setenv(config.TASK_AUTO_RESUME_ENABLED, str(auto_resume).lower())
read = config.get_task_infra_failure_pause_enabled
for unset in (None, "", "maybe"):
if unset is None:
monkeypatch.delenv(
config.TASK_INFRA_FAILURE_PAUSE_ENABLED, raising=False
)
else:
monkeypatch.setenv(config.TASK_INFRA_FAILURE_PAUSE_ENABLED, unset)
assert read() is auto_resume
monkeypatch.setenv(config.TASK_INFRA_FAILURE_PAUSE_ENABLED, "true")
assert read() is True
monkeypatch.setenv(config.TASK_INFRA_FAILURE_PAUSE_ENABLED, "false")
assert read() is False
def test_example_env_documents_every_setting(self):
example = (Path(config.__file__).parents[2] / "example.env").read_text()
names = [f"XAGENT_{const}" for const, *_ in _AUTO_RESUME_INT_SETTINGS]
names += [f"XAGENT_{const}" for const, *_ in _AUTO_RESUME_BOOL_SETTINGS]
for name in names:
assert f"# {name}=" in example
@pytest.mark.parametrize(
("raw", "expected", "warns"),
[
(None, 80, False),
("7", 7, False),
("1", 1, False),
(" 7 ", 7, False),
("100000", 100000, False),
("0", 80, True),
("-1", 80, True),
("abc", 80, True),
("", 80, True),
("7.5", 80, True),
],
)
def test_dispatcher_max_inflight_env_parsing(monkeypatch, caplog, raw, expected, warns):
env_var = config.DISPATCHER_MAX_INFLIGHT_PER_PROCESS
assert env_var == "XAGENT_DISPATCHER_MAX_INFLIGHT_PER_PROCESS"
if raw is None:
monkeypatch.delenv(env_var, raising=False)
else:
monkeypatch.setenv(env_var, raw)
caplog.clear()
with caplog.at_level(logging.WARNING, logger="xagent.config"):
assert config.get_dispatcher_max_inflight_per_process() == expected
warnings = [
record
for record in caplog.records
if record.name == "xagent.config" and record.levelno == logging.WARNING
]
assert len(warnings) == int(warns)
assert all(env_var in record.getMessage() for record in warnings)
@pytest.mark.parametrize(
("raw", "expected", "warns"),
[
(None, 0, False),
("0", 0, False),
("4", 4, False),
(" 4 ", 4, False),
("-1", 0, True),
("abc", 0, True),
("", 0, True),
("1.5", 0, True),
],
)
def test_dispatcher_interactive_reserve_env_parsing(
monkeypatch, caplog, raw, expected, warns
):
env_var = config.DISPATCHER_INTERACTIVE_RESERVE_PER_PROCESS
assert env_var == "XAGENT_DISPATCHER_INTERACTIVE_RESERVE_PER_PROCESS"
if raw is None:
monkeypatch.delenv(env_var, raising=False)
else:
monkeypatch.setenv(env_var, raw)
caplog.clear()
with caplog.at_level(logging.WARNING, logger="xagent.config"):
assert config.get_dispatcher_interactive_reserve_per_process() == expected
warnings = [
record
for record in caplog.records
if record.name == "xagent.config" and record.levelno == logging.WARNING
]
assert len(warnings) == int(warns)
assert all(env_var in record.getMessage() for record in warnings)
@pytest.mark.parametrize(
("const", "env_var", "getter"),
[
(
"DISPATCHER_FAIR_SHARE",
"XAGENT_DISPATCHER_FAIR_SHARE",
"get_dispatcher_fair_share_enabled",
),
(
"DISPATCH_ACCEPT_REQUESTED_CLASS",
"XAGENT_DISPATCH_ACCEPT_REQUESTED_CLASS",
"get_dispatch_accept_requested_class_enabled",
),
],
)
@pytest.mark.parametrize(
("raw", "expected", "warns"),
[
(None, False, False),
("true", True, False),
("TRUE", True, False),
("True", True, False),
("1", True, False),
("yes", True, False),
("YES", True, False),
("on", True, False),
("On", True, False),
("false", False, False),
("FALSE", False, False),
("0", False, False),
("no", False, False),
("off", False, False),
# A blank value states nothing, as when a compose file interpolates an
# unset variable: unlike the numeric settings above, it does not warn.
("", False, False),
(" ", False, False),
("garbage", False, True),
],
)
def test_dispatch_switch_env_parsing(
monkeypatch, caplog, const, env_var, getter, raw, expected, warns
):
assert getattr(config, const) == env_var
if raw is None:
monkeypatch.delenv(env_var, raising=False)
else:
monkeypatch.setenv(env_var, raw)
caplog.clear()
with caplog.at_level(logging.WARNING, logger="xagent.config"):
assert getattr(config, getter)() is expected
warnings = [
record
for record in caplog.records
if record.name == "xagent.config" and record.levelno == logging.WARNING
]
assert len(warnings) == int(warns)
assert all(env_var in record.getMessage() for record in warnings)
@pytest.mark.parametrize(
"name,value",
[
("XAGENT_EXECUTION_BUDGET_DEFAULT_TOKENS", "-1"),
("XAGENT_EXECUTION_BUDGET_MAX_TOKENS", "0"),
("XAGENT_EXECUTION_BUDGET_SOFT_PERCENT", "100"),
("XAGENT_EXECUTION_BUDGET_SOFT_PERCENT", "no"),
],
)
def test_execution_budget_invalid_env_rejected(monkeypatch, name, value):
from xagent.config import get_execution_budget_defaults
monkeypatch.setenv(name, value)
with pytest.raises(ValueError):
get_execution_budget_defaults()
def test_execution_budget_env_defaults(monkeypatch):
from xagent.config import get_execution_budget_defaults
for key in ("DEFAULT_TOKENS", "MAX_TOKENS", "SOFT_PERCENT"):
monkeypatch.delenv(f"XAGENT_EXECUTION_BUDGET_{key}", raising=False)
assert get_execution_budget_defaults() == {
"default_tokens": None,
"max_tokens": None,
"soft_limit_percent": 80,
}
monkeypatch.setenv("XAGENT_EXECUTION_BUDGET_DEFAULT_TOKENS", "12345")
monkeypatch.setenv("XAGENT_EXECUTION_BUDGET_SOFT_PERCENT", "65")
assert get_execution_budget_defaults()["default_tokens"] == 12345
assert get_execution_budget_defaults()["soft_limit_percent"] == 65
def test_execution_budget_env_default_cannot_exceed_maximum(monkeypatch):
from xagent.config import get_execution_budget_defaults
monkeypatch.setenv("XAGENT_EXECUTION_BUDGET_DEFAULT_TOKENS", "200")
monkeypatch.setenv("XAGENT_EXECUTION_BUDGET_MAX_TOKENS", "100")
with pytest.raises(ValueError, match="must not exceed"):
get_execution_budget_defaults()
_READ_BUDGET_GETTERS = [
("XAGENT_EXECUTION_EVENT_READ_ROW_BUDGETS", "get_execution_event_read_row_budgets"),
(
"XAGENT_EXECUTION_EVENT_READ_DURATION_BUDGETS_MS",
"get_execution_event_read_duration_budgets_ms",
),
]
@pytest.mark.parametrize("env_var,getter", _READ_BUDGET_GETTERS)
@pytest.mark.parametrize("value", [None, "", " ", " , "])
def test_execution_event_read_budgets_unset_or_empty_means_no_budget(
monkeypatch, env_var, getter, value
):
from xagent import config
if value is None:
monkeypatch.delenv(env_var, raising=False)
else:
monkeypatch.setenv(env_var, value)
assert dict(getattr(config, getter)()) == {}
@pytest.mark.parametrize("env_var,getter", _READ_BUDGET_GETTERS)
def test_execution_event_read_budgets_parse_operations_and_default(
monkeypatch, env_var, getter
):
from xagent import config
monkeypatch.setenv(env_var, "model=2000, reconnect = 20000 ,*=50000,")
assert dict(getattr(config, getter)()) == {
"model": 2000,
"reconnect": 20000,
"*": 50000,
}
monkeypatch.setenv(env_var, "Tool_Outcome=7")
assert dict(getattr(config, getter)()) == {"tool_outcome": 7}
monkeypatch.setenv(
env_var, "model=1,display=2,reconnect=3,checkpoint=4,tool_outcome=5"
)
assert dict(getattr(config, getter)()) == {
"model": 1,
"display": 2,
"reconnect": 3,
"checkpoint": 4,
"tool_outcome": 5,
}
@pytest.mark.parametrize("env_var,getter", _READ_BUDGET_GETTERS)
@pytest.mark.parametrize(
"value,message",
[
("model=abc", "positive integer"),
("model=1.5", "positive integer"),
("model=", "positive integer"),
("model=-5", "positive integer"),
("model=0", "positive integer"),
("*=0", "positive integer"),
("model", "<operation>=<positive integer>"),
("=5", "unknown operation"),
("models=5", "unknown operation"),
("replay=5", "unknown operation"),
("model=1,model=2", "duplicate"),
],
)
def test_execution_event_read_budgets_invalid_values_raise(
monkeypatch, env_var, getter, value, message
):
from xagent import config
monkeypatch.setenv(env_var, value)
with pytest.raises(ValueError, match=message) as error:
getattr(config, getter)()
assert env_var in str(error.value)
@pytest.mark.parametrize("env_var,getter", _READ_BUDGET_GETTERS)
def test_execution_event_read_budgets_cache_by_raw_value_and_follow_env(
monkeypatch, env_var, getter
):
from xagent import config
config._parse_execution_event_read_budgets.cache_clear()
monkeypatch.setenv(env_var, "model=10")
first = getattr(config, getter)()
parses = config._parse_execution_event_read_budgets.cache_info()
assert getattr(config, getter)() is first
after = config._parse_execution_event_read_budgets.cache_info()
assert (after.misses, after.hits) == (parses.misses, parses.hits + 1)
monkeypatch.setenv(env_var, "model=20")
assert dict(getattr(config, getter)()) == {"model": 20}
monkeypatch.delenv(env_var)
assert dict(getattr(config, getter)()) == {}
# A cached result cannot be mutated by a caller.
with pytest.raises(TypeError):
first["model"] = 1 # type: ignore[index]
@pytest.mark.parametrize("value", [None, "", " ", " development ", "DEVELOPMENT"])
def test_environment_defaults_and_normalizes_development(monkeypatch, value):
monkeypatch.delenv("ENVIRONMENT", raising=False)
if value is None:
monkeypatch.delenv("XAGENT_ENVIRONMENT", raising=False)
else:
monkeypatch.setenv("XAGENT_ENVIRONMENT", value)
assert config.get_environment() == "development"
def test_legacy_environment_alias_is_normalized(monkeypatch):
monkeypatch.delenv("XAGENT_ENVIRONMENT", raising=False)
monkeypatch.setenv("ENVIRONMENT", " Production ")
assert config.get_environment() == "production"
def test_blank_environment_override_falls_back_to_legacy_alias(monkeypatch):
monkeypatch.setenv("XAGENT_ENVIRONMENT", " ")
monkeypatch.setenv("ENVIRONMENT", " production ")
assert config.get_environment() == "production"
@pytest.mark.parametrize("setting", ["XAGENT_SECRET_ENCRYPTION_KEY", "SECRET_KEY"])
@pytest.mark.parametrize("length,valid", [(31, False), (32, True)])
def test_tool_key_alias_and_boundary(monkeypatch, setting, length, valid):
monkeypatch.setenv("XAGENT_ENVIRONMENT", "production")
monkeypatch.setenv("XAGENT_SECRET_ENCRYPTION_KEY", " ")
monkeypatch.delenv("SECRET_KEY", raising=False)
monkeypatch.setenv(setting, "s" * length)
if valid:
assert config.get_tool_credentials_encryption_key() == "s" * length
else:
with pytest.raises(RuntimeError, match=f"^{setting} must"):
config.get_tool_credentials_encryption_key()
@pytest.mark.parametrize("setting", ["XAGENT_SECRET_ENCRYPTION_KEY", "SECRET_KEY"])
@pytest.mark.parametrize(
"value",
sorted(value for value in config.KNOWN_INSECURE_SECRETS if len(value) >= 32),
)
def test_tool_key_rejects_known_public_values_including_alias(
monkeypatch, setting, value
):
monkeypatch.setenv("XAGENT_ENVIRONMENT", "production")
monkeypatch.delenv("XAGENT_SECRET_ENCRYPTION_KEY", raising=False)
monkeypatch.delenv("SECRET_KEY", raising=False)
monkeypatch.setenv(setting, " " + value.upper() + " ")
with pytest.raises(
RuntimeError, match=f"^{setting} must not use a public placeholder"
):
config.get_tool_credentials_encryption_key()
@pytest.mark.parametrize(
"key",
[
config.DEV_FALLBACK_ENCRYPTION_KEY,
config.DEV_FALLBACK_ENCRYPTION_KEY.replace("_", "/"),
config.DEV_FALLBACK_ENCRYPTION_KEY + "=",
config.DEV_FALLBACK_ENCRYPTION_KEY[:10]
+ "\n"
+ config.DEV_FALLBACK_ENCRYPTION_KEY[10:],
],
)
def test_deployed_encryption_rejects_published_fernet_key(monkeypatch, key):
monkeypatch.setenv("XAGENT_ENVIRONMENT", "production")
monkeypatch.setenv("ENCRYPTION_KEY", key)
with pytest.raises(
RuntimeError, match="^ENCRYPTION_KEY must provide a private Fernet key$"
):
config.validate_encryption_config()
@pytest.mark.parametrize(
"setting,getter,default",
[
(
"XAGENT_AUTH_RATE_LIMIT_WINDOW_SECONDS",
config.get_auth_rate_limit_window_seconds,
900,
),
("XAGENT_AUTH_LOGIN_IP_LIMIT", config.get_auth_login_ip_limit, 200),
("XAGENT_AUTH_LOGIN_ACCOUNT_LIMIT", config.get_auth_login_account_limit, 50),
("XAGENT_AUTH_LOGIN_PAIR_LIMIT", config.get_auth_login_pair_limit, 5),
("XAGENT_AUTH_RECOVERY_IP_LIMIT", config.get_auth_recovery_ip_limit, 200),
("XAGENT_AUTH_RECOVERY_EMAIL_LIMIT", config.get_auth_recovery_email_limit, 50),
("XAGENT_AUTH_RECOVERY_PAIR_LIMIT", config.get_auth_recovery_pair_limit, 5),
("XAGENT_EMAIL_CHANGE_TARGET_LIMIT", config.get_email_change_target_limit, 5),
(
"XAGENT_EMAIL_CONFIRMATION_EXPIRE_MINUTES",
config.get_email_confirmation_expire_minutes,
15,
),
(
"XAGENT_AUTH_RATE_LIMIT_MAX_LOCAL_KEYS",
config.get_auth_rate_limit_max_local_keys,
10000,
),
],
)
def test_auth_rate_budget_configuration(monkeypatch, setting, getter, default):
monkeypatch.delenv(setting, raising=False)
assert getter() == default
monkeypatch.setenv(setting, "123")
assert getter() == 123
for invalid in ("", "0", "-1", "invalid"):
monkeypatch.setenv(setting, invalid)
assert getter() == default
@pytest.mark.parametrize(
"kind,default", [("image", 64 * 1024 * 1024), ("video", 512 * 1024 * 1024)]
)
def test_media_download_size_defaults_and_overrides(monkeypatch, kind, default):
variable = f"XAGENT_{kind.upper()}_DOWNLOAD_MAX_BYTES"
monkeypatch.delenv(variable, raising=False)
assert config.get_media_download_max_bytes(kind) == default
monkeypatch.setenv(variable, "123")
assert config.get_media_download_max_bytes(kind) == 123
for blank in ("", " ", "\t"):
monkeypatch.setenv(variable, blank)
assert config.get_media_download_max_bytes(kind) == default
@pytest.mark.parametrize("value", ["0", "-1", "invalid", "1.5"])
def test_media_download_size_rejects_invalid_limits(monkeypatch, value):
monkeypatch.setenv("XAGENT_IMAGE_DOWNLOAD_MAX_BYTES", value)
with pytest.raises(ValueError):
config.get_media_download_max_bytes("image")
def test_sql_worker_url_and_token_configuration(monkeypatch):
monkeypatch.setenv("XAGENT_SQL_WORKER_URL", " http://sql-worker:8090/ ")
monkeypatch.setenv("XAGENT_SQL_WORKER_TOKEN", " worker-secret ")
assert config.get_sql_worker_url() == "http://sql-worker:8090"
assert config.get_sql_worker_token() == "worker-secret"
@pytest.mark.parametrize(
"value",
[
"sql-worker:8090",
"ftp://sql-worker",
"http://sql-worker/path?token=secret",
"http://user:password@sql-worker:8090",
],
)
def test_sql_worker_url_rejects_unsafe_values(monkeypatch, value):
monkeypatch.setenv("XAGENT_SQL_WORKER_URL", value)
with pytest.raises(ValueError, match="XAGENT_SQL_WORKER_URL"):
config.get_sql_worker_url()
@pytest.mark.parametrize(
"setting,getter,default",
[
(
"XAGENT_SQL_WORKER_QUERY_TIMEOUT_SECONDS",
config.get_sql_worker_query_timeout_seconds,
30,
),
("XAGENT_SQL_WORKER_MAX_ROWS", config.get_sql_worker_max_rows, 10_000),
(
"XAGENT_SQL_WORKER_MAX_RESULT_BYTES",
config.get_sql_worker_max_result_bytes,
8 * 1024 * 1024,
),
(
"XAGENT_SQL_WORKER_MAX_QUERY_BYTES",
config.get_sql_worker_max_query_bytes,
1024 * 1024,
),
(
"XAGENT_SQL_WORKER_MAX_CONCURRENCY",
config.get_sql_worker_max_concurrency,
4,
),
],
)
def test_sql_worker_limits(monkeypatch, setting, getter, default):
monkeypatch.delenv(setting, raising=False)
assert getter() == default
monkeypatch.setenv(setting, "7")
assert getter() == 7
def test_sql_worker_host_and_port(monkeypatch):
monkeypatch.delenv("XAGENT_SQL_WORKER_HOST", raising=False)
monkeypatch.delenv("XAGENT_SQL_WORKER_PORT", raising=False)
assert config.get_sql_worker_host() == "0.0.0.0"
assert config.get_sql_worker_port() == 8090
monkeypatch.setenv("XAGENT_SQL_WORKER_HOST", "127.0.0.1")
monkeypatch.setenv("XAGENT_SQL_WORKER_PORT", "18090")
assert config.get_sql_worker_host() == "127.0.0.1"
assert config.get_sql_worker_port() == 18090
monkeypatch.setenv("XAGENT_SQL_WORKER_PORT", "70000")
with pytest.raises(ValueError, match="XAGENT_SQL_WORKER_PORT"):
config.get_sql_worker_port()
def test_remote_json_download_size_default_and_override(monkeypatch):
monkeypatch.delenv("XAGENT_REMOTE_JSON_DOWNLOAD_MAX_BYTES", raising=False)
assert config.get_remote_json_download_max_bytes() == 10 * 1024 * 1024
for value in ("", " "):
monkeypatch.setenv("XAGENT_REMOTE_JSON_DOWNLOAD_MAX_BYTES", value)
assert config.get_remote_json_download_max_bytes() == 10 * 1024 * 1024
for value, expected in (("123", 123), ("2K", 2048), ("1.5M", 1572864)):
monkeypatch.setenv("XAGENT_REMOTE_JSON_DOWNLOAD_MAX_BYTES", value)
assert config.get_remote_json_download_max_bytes() == expected
@pytest.mark.parametrize("value", ["0", "-1", "invalid", "1.5", "nan", "inf"])
def test_remote_json_download_size_rejects_invalid_limits(monkeypatch, value):
monkeypatch.setenv("XAGENT_REMOTE_JSON_DOWNLOAD_MAX_BYTES", value)
with pytest.raises(ValueError):
config.get_remote_json_download_max_bytes()
def test_private_model_config_is_default_empty_and_environment_only(monkeypatch):
assert config.get_model_private_endpoints() == []
assert config.get_model_private_cidrs() == []
monkeypatch.setenv("XAGENT_MODEL_PRIVATE_ENDPOINTS", " http://localhost:9997, ")
monkeypatch.setenv("XAGENT_MODEL_PRIVATE_CIDRS", " 127.0.0.1/32,::1/128 ")
assert config.get_model_private_endpoints() == ["http://localhost:9997"]
assert config.get_model_private_cidrs() == ["127.0.0.1/32", "::1/128"]
class TestZendeskMarketplaceHeaders:
"""#3222: Zendesk Marketplace review checks these headers on API calls."""
ENV_VARS = (
"ZENDESK_MARKETPLACE_NAME",
"ZENDESK_MARKETPLACE_ORGANIZATION_ID",
"ZENDESK_MARKETPLACE_APP_ID",
)
@pytest.fixture(autouse=True)
def _unset(self, monkeypatch):
for name in self.ENV_VARS:
monkeypatch.delenv(name, raising=False)
def test_unconfigured_sends_no_headers(self, monkeypatch):
assert config.get_zendesk_marketplace_headers() == {}
for name in self.ENV_VARS:
monkeypatch.setenv(name, " ")
assert config.get_zendesk_marketplace_headers() == {}
def test_all_three_settings_map_to_their_headers(self, monkeypatch):
monkeypatch.setenv("ZENDESK_MARKETPLACE_NAME", " Xagent for Zendesk ")
monkeypatch.setenv("ZENDESK_MARKETPLACE_ORGANIZATION_ID", "12345")
monkeypatch.setenv("ZENDESK_MARKETPLACE_APP_ID", "67890")
assert config.get_zendesk_marketplace_headers() == {
"X-Zendesk-Marketplace-Name": "Xagent for Zendesk",
"X-Zendesk-Marketplace-Organization-Id": "12345",
"X-Zendesk-Marketplace-App-Id": "67890",
}
def test_a_partial_configuration_sends_the_headers_that_are_set(self, monkeypatch):
# The app ID is only assigned once the app is submitted, while review
# already checks for the headers.
monkeypatch.setenv("ZENDESK_MARKETPLACE_NAME", "Xagent")
monkeypatch.setenv("ZENDESK_MARKETPLACE_ORGANIZATION_ID", "12345")
assert config.get_zendesk_marketplace_headers() == {
"X-Zendesk-Marketplace-Name": "Xagent",
"X-Zendesk-Marketplace-Organization-Id": "12345",
}
@pytest.mark.parametrize(
"value",
[
"Xagent\r\nX-Injected: 1",
"Xagent\nfor Zendesk",
"Xagent\tfor Zendesk",
"Xagent für Zendesk",
"x" * 257,
],
)
def test_an_invalid_value_is_ignored_with_a_warning(
self, monkeypatch, caplog, value
):
monkeypatch.setenv("ZENDESK_MARKETPLACE_NAME", value)
monkeypatch.setenv("ZENDESK_MARKETPLACE_ORGANIZATION_ID", "12345")
with caplog.at_level(logging.WARNING, logger="xagent.config"):
headers = config.get_zendesk_marketplace_headers()
assert headers == {"X-Zendesk-Marketplace-Organization-Id": "12345"}
assert "ZENDESK_MARKETPLACE_NAME" in caplog.text
# The rejected value itself is never echoed into the logs.
assert value.strip() not in caplog.text
def test_the_maximum_length_is_accepted(self, monkeypatch):
monkeypatch.setenv("ZENDESK_MARKETPLACE_APP_ID", "1" * 256)
assert config.get_zendesk_marketplace_headers() == {
"X-Zendesk-Marketplace-App-Id": "1" * 256
}
def test_python_executor_timeout_default_and_override(monkeypatch):
monkeypatch.delenv("XAGENT_PYTHON_EXECUTOR_TIMEOUT_SECONDS", raising=False)
assert config.get_python_executor_timeout_seconds() == 1200
monkeypatch.setenv("XAGENT_PYTHON_EXECUTOR_TIMEOUT_SECONDS", "45")
assert config.get_python_executor_timeout_seconds() == 45
@pytest.mark.parametrize("value", ["0", "-5", "soon"])
def test_python_executor_timeout_rejects_invalid_values(monkeypatch, value):
monkeypatch.setenv("XAGENT_PYTHON_EXECUTOR_TIMEOUT_SECONDS", value)
assert config.get_python_executor_timeout_seconds() == 1200
def test_public_site_configuration_is_opt_in(monkeypatch):
from xagent.config import (
get_dual_entry_oauth_enabled,
get_primary_public_site_url,
get_public_entries,
)
monkeypatch.delenv("XAGENT_PUBLIC_ENTRIES_JSON", raising=False)
monkeypatch.delenv("XAGENT_PRIMARY_PUBLIC_SITE_URL", raising=False)
monkeypatch.delenv("XAGENT_DUAL_ENTRY_OAUTH_ENABLED", raising=False)
monkeypatch.setenv("XAGENT_APP_BASE_URL", "https://legacy.example")
monkeypatch.setenv("XAGENT_REGION_COOKIE_DOMAIN", ".legacy.example")
assert get_primary_public_site_url() == "https://legacy.example"
# The unconfigured legacy entry never carries a hosting cookie domain.
assert get_public_entries()[0].region_cookie_domain is None
assert not get_dual_entry_oauth_enabled()
@pytest.mark.parametrize(
"value, expected", [(None, False), ("true", True), ("false", False)]
)
def test_get_sandbox_enabled(monkeypatch, value, expected):
from xagent.config import get_sandbox_enabled
if value is None:
monkeypatch.delenv("SANDBOX_ENABLED", raising=False)
else:
monkeypatch.setenv("SANDBOX_ENABLED", value)
assert get_sandbox_enabled() is expected
def test_legacy_source_uploads_boundary_ignores_operator_overrides(monkeypatch):
from xagent.config import get_legacy_source_uploads_dir
expected = get_legacy_source_uploads_dir()
monkeypatch.setenv("XAGENT_WEB_DIR", "/unrelated")
monkeypatch.setenv("XAGENT_UPLOADS_DIR", "/")
assert get_legacy_source_uploads_dir() == expected
def test_platform_git_roots_follow_relative_alternates_without_looping(
tmp_path, monkeypatch
):
from xagent.config import get_platform_source_roots
checkout = tmp_path / "checkout"
(checkout / "src" / "xagent").mkdir(parents=True)
(checkout / "pyproject.toml").write_text('[project]\nname = "xagent-ai"\n')
objects = checkout / ".git" / "objects"
pool = tmp_path / "pool"
for path in (objects, pool):
(path / "info").mkdir(parents=True)
(objects / "info" / "alternates").write_text(os.path.relpath(pool, objects) + "\n")
(pool / "info" / "alternates").write_text(os.path.relpath(objects, pool) + "\n")
monkeypatch.chdir(checkout)
roots = get_platform_source_roots()
assert (checkout / ".git").resolve() in roots
assert objects.resolve() in roots
assert pool.resolve() in roots
class TestComposioCallbackUrlConfig:
"""XAGENT_COMPOSIO_CALLBACK_URL: the one callback of every Composio connect."""
def test_constant(self):
assert config.COMPOSIO_CALLBACK_URL == "XAGENT_COMPOSIO_CALLBACK_URL"
def test_unset_or_blank_keeps_the_meta_callback(self, monkeypatch):
monkeypatch.delenv(config.COMPOSIO_CALLBACK_URL, raising=False)
assert config.get_composio_callback_url() is None
monkeypatch.setenv(config.COMPOSIO_CALLBACK_URL, " ")
assert config.get_composio_callback_url() is None
def test_strips_whitespace_and_a_trailing_slash(self, monkeypatch):
monkeypatch.setenv(
config.COMPOSIO_CALLBACK_URL,
" https://app.example.com/api/auth/composio/callback/ ",
)
assert (
config.get_composio_callback_url()
== "https://app.example.com/api/auth/composio/callback"
)
@pytest.mark.parametrize(
"value",
[
"app.example.com/api/auth/composio/callback",
"ftp://app.example.com/api/auth/composio/callback",
"https://app.example.com/api/auth/composio/callback?x=1",
"https://app.example.com/api/auth/composio/callback#x",
"https://user:[email protected]/api/auth/composio/callback",
],
ids=["no-scheme", "ftp", "query", "fragment", "credentials"],
)
def test_rejects_an_unusable_url(self, monkeypatch, value):
monkeypatch.setenv(config.COMPOSIO_CALLBACK_URL, value)
with pytest.raises(ValueError, match="XAGENT_COMPOSIO_CALLBACK_URL"):
config.get_composio_callback_url()
@pytest.mark.parametrize(
("getter", "env", "lower"),
[
(
config.get_execution_event_storage_entries,
config.EXECUTION_EVENT_STORAGE_ENTRIES,
True,
),
(
config.get_execution_event_storage_user_ids,
config.EXECUTION_EVENT_STORAGE_USER_IDS,
False,
),
],
)
def test_execution_event_storage_getters_raw_parsing(monkeypatch, getter, env, lower):
monkeypatch.delenv(env, raising=False)
assert getter() == []
monkeypatch.setenv(env, "")
assert getter() == []
monkeypatch.setenv(env, " ")
assert getter() == []
monkeypatch.setenv(env, " Sdk ,, A2A , sdk,")
expected = ["sdk", "a2a", "sdk"] if lower else ["Sdk", "A2A", "sdk"]
assert getter() == expected
def test_execution_event_storage_getters_do_not_validate(monkeypatch):
monkeypatch.setenv(config.EXECUTION_EVENT_STORAGE_USER_IDS, "1, abc, -2")
assert config.get_execution_event_storage_user_ids() == ["1", "abc", "-2"]