Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

14.3 KB
Raw Blame
from __future__ import annotations

import ast
import os
import subprocess
import sys
import unittest
from pathlib import Path


ASSET_DIR = Path(__file__).resolve().parents[1]
COMMON_PATH = ASSET_DIR / "common.sh"
ENTRYPOINT_PATH = ASSET_DIR / "entrypoint.sh"
HEALTHCHECK_PATH = ASSET_DIR / "healthcheck.sh"
RUN_SERVICE_PATH = ASSET_DIR / "run-service.sh"
DOCKERFILE_PATH = ASSET_DIR / "Dockerfile"
SUPERVISOR_PATH = ASSET_DIR / "supervisor" / "supervisord.conf"
BACKEND_SERVICE_PATH = ASSET_DIR.parent / "backend" / "backend" / "util" / "service.py"


class InternalServiceTopologyTest(unittest.TestCase):
    def test_prepares_marketplace_media_for_unprivileged_backend(self) -> None:
        result = subprocess.run(
            [
                "bash",
                "-Eeuo",
                "pipefail",
                "-c",
                'source "$1"; install() { printf "%s\\n" "$*"; }; prepare_directories',
                "bash",
                str(ENTRYPOINT_PATH),
            ],
            check=False,
            capture_output=True,
            encoding="utf-8",
            env={
                "PATH": os.environ.get("PATH", "/usr/bin:/bin"),
                "AUTOGPT_ASSET_DIR": str(ASSET_DIR),
            },
        )
        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertIn(
            "-d -m 0750 -o autogpt -g autogpt /data/store-media",
            result.stdout.splitlines(),
        )

    def test_rpc_health_path_matches_backend(self) -> None:
        module = ast.parse(BACKEND_SERVICE_PATH.read_text(encoding="utf-8"))
        route_paths = {
            ast.literal_eval(node.args[0])
            for node in ast.walk(module)
            if isinstance(node, ast.Call)
            and isinstance(node.func, ast.Attribute)
            and node.func.attr == "add_api_route"
            and node.args
            and isinstance(node.args[0], ast.Constant)
            and isinstance(node.args[0].value, str)
        }
        result = subprocess.run(
            [
                "bash",
                "-Eeuo",
                "pipefail",
                "-c",
                'source "$1"; printf "%s" "$AUTOGPT_INTERNAL_HEALTH_PATH"',
                "bash",
                str(COMMON_PATH),
            ],
            check=False,
            capture_output=True,
            encoding="utf-8",
            env={"PATH": os.environ.get("PATH", "/usr/bin:/bin")},
        )

        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertIn(result.stdout, route_paths)
        self.assertIn(
            "${AUTOGPT_INTERNAL_HEALTH_PATH}",
            HEALTHCHECK_PATH.read_text(encoding="utf-8"),
        )


class AccountRegistrationTest(unittest.TestCase):
    def test_defaults_open_for_all_origins(self) -> None:
        for public_url in (
            "http://localhost:3000",
            "http://127.0.0.1:3000",
            "http://[::1]:3000",
            "https://autogpt.example.com",
        ):
            for allow_new_accounts in (None, ""):
                with self.subTest(
                    public_url=public_url,
                    allow_new_accounts=allow_new_accounts,
                ):
                    result = self._configure(public_url, allow_new_accounts)
                    self.assertEqual(result.returncode, 0, result.stderr)
                    self.assertIn("open account registration is enabled", result.stdout)
                    self.assertTrue(result.stdout.endswith("true\n"))

    def test_explicit_true_keeps_signup_open(self) -> None:
        result = self._configure(
            "https://autogpt.example.com", allow_new_accounts="true"
        )
        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertIn("open account registration is enabled", result.stdout)
        self.assertTrue(result.stdout.endswith("true\n"))

    def test_explicit_false_closes_signup(self) -> None:
        result = self._configure("http://localhost:3000", allow_new_accounts="false")
        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertIn("account registration is closed", result.stdout)
        self.assertTrue(result.stdout.endswith("false\n"))

    def _configure(
        self, public_url: str, allow_new_accounts: str | None = None
    ) -> subprocess.CompletedProcess[str]:
        environment = {
            "PATH": os.environ.get("PATH", "/usr/bin:/bin"),
            "AUTOGPT_ASSET_DIR": str(ASSET_DIR),
            "AUTOGPT_PUBLIC_URL": public_url,
        }
        if allow_new_accounts is not None:
            environment["AUTH_ALLOW_NEW_ACCOUNTS"] = allow_new_accounts
        return subprocess.run(
            [
                "bash",
                "-Eeuo",
                "pipefail",
                "-c",
                'source "$1"; configure_account_registration; '
                'printf "%s\\n" "$AUTH_ALLOW_NEW_ACCOUNTS"',
                "bash",
                str(ENTRYPOINT_PATH),
            ],
            check=False,
            capture_output=True,
            encoding="utf-8",
            env=environment,
        )


class EnvironmentPolicyTest(unittest.TestCase):
    def test_image_preserves_background_embedding_backfill_at_startup(
        self,
    ) -> None:
        dockerfile = DOCKERFILE_PATH.read_text(encoding="utf-8")

        self.assertNotIn("SCHEDULER_STARTUP_EMBEDDING_BACKFILL=false", dockerfile)

    def test_rejects_required_email_verification(self) -> None:
        result = self._configure(AUTH_REQUIRE_EMAIL_VERIFICATION="true")

        self.assertNotEqual(result.returncode, 0)
        self.assertIn(
            "email verification is not supported by the single-container distribution",
            result.stderr,
        )

    def test_defaults_to_local_behavior(self) -> None:
        result = self._configure()

        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertEqual(result.stdout.splitlines()[-1], "local")

    def test_preserves_cloud_behavior_override(self) -> None:
        result = self._configure(BEHAVE_AS="cloud")

        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertEqual(result.stdout.splitlines()[-1], "cloud")

    def test_disables_copilot_spend_caps_by_default(self) -> None:
        # Self-hosted operators pay the provider directly, so the cloud
        # daily/weekly USD caps must not apply unless explicitly configured.
        result = self._configure(output=_COPILOT_SPEND_CAPS)

        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertEqual(result.stdout.splitlines()[-1], "-1 -1")

    def test_preserves_operator_copilot_spend_caps(self) -> None:
        # A blank template field arrives as an empty string and must fall
        # back to the sentinel rather than reach Pydantic as a non-integer.
        result = self._configure(
            output=_COPILOT_SPEND_CAPS,
            CHAT_DAILY_COST_LIMIT_MICRODOLLARS="2500000",
            CHAT_WEEKLY_COST_LIMIT_MICRODOLLARS="",
        )

        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertEqual(result.stdout.splitlines()[-1], "2500000 -1")

    def _configure(
        self, *, output: str = "$BEHAVE_AS", **overrides: str
    ) -> subprocess.CompletedProcess[str]:
        environment = {
            "PATH": os.environ.get("PATH", "/usr/bin:/bin"),
            "AUTOGPT_ASSET_DIR": str(ASSET_DIR),
            "AUTOGPT_BACKEND_DIR": str(ASSET_DIR.parent / "backend"),
            "AUTOGPT_PYTHON": sys.executable,
            "AUTOGPT_PUBLIC_URL": "http://localhost:3000",
            "AUTH_ALLOW_NEW_ACCOUNTS": "false",
            "POSTGRES_PASSWORD": "test-postgres",
            "RABBITMQ_DEFAULT_USER": "test-rabbitmq",
            "RABBITMQ_DEFAULT_PASS": "test-rabbitmq",
            "REDIS_PASSWORD": "test-redis",
            "BETTER_AUTH_SECRET": "test-better-auth",
            "ENCRYPTION_KEY": "test-encryption",
            "UNSUBSCRIBE_SECRET_KEY": "test-unsubscribe",
            "GRAPHITI_FALKORDB_PASSWORD": "test-falkordb",
            "VAPID_PRIVATE_KEY": "test-vapid-private",
            "VAPID_PUBLIC_KEY": "test-vapid-public",
        }
        environment.update(overrides)
        return subprocess.run(
            [
                "bash",
                "-Eeuo",
                "pipefail",
                "-c",
                'source "$1"; write_nginx_public_url_config() { :; }; '
                f'configure_environment; printf "%s\\n" "{output}"',
                "bash",
                str(ENTRYPOINT_PATH),
            ],
            check=False,
            capture_output=True,
            encoding="utf-8",
            env=environment,
        )


_COPILOT_SPEND_CAPS = (
    "$CHAT_DAILY_COST_LIMIT_MICRODOLLARS $CHAT_WEEKLY_COST_LIMIT_MICRODOLLARS"
)


class PublicOriginConfigurationTest(unittest.TestCase):
    def test_backend_cors_uses_the_validated_public_origin(self) -> None:
        result = subprocess.run(
            [
                "bash",
                "-Eeuo",
                "pipefail",
                "-c",
                'source "$1"; AUTOGPT_PUBLIC_URL="$2"; '
                "configure_backend_cors_origin; "
                'printf "%s\\n" "$BACKEND_CORS_ALLOW_ORIGINS"',
                "bash",
                str(ENTRYPOINT_PATH),
                "http://192.168.1.254:3300",
            ],
            check=False,
            capture_output=True,
            encoding="utf-8",
            env={
                "PATH": os.environ.get("PATH", "/usr/bin:/bin"),
                "AUTOGPT_ASSET_DIR": str(ASSET_DIR),
            },
        )

        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertEqual(result.stdout, '["http://192.168.1.254:3300"]\n')


class NormalizationTest(unittest.TestCase):
    def test_rejects_invalid_integer_values(self) -> None:
        for value, error in (
            ("not-a-number", "must be an integer"),
            ("0", "must be between 1 and 5"),
            ("6", "must be between 1 and 5"),
        ):
            with self.subTest(value=value):
                result = self._run(
                    'DB_CONNECTION_LIMIT="$2"; '
                    "normalize_integer DB_CONNECTION_LIMIT 5 1 5",
                    value,
                )
                self.assertNotEqual(result.returncode, 0)
                self.assertIn(error, result.stderr)

    def test_rejects_invalid_toggle(self) -> None:
        invalid = self._run(
            'AUTOGPT_ENABLE_BOT_SERVICES="$2"; normalize_toggle AUTOGPT_ENABLE_BOT_SERVICES false',
            "yes",
        )
        self.assertNotEqual(invalid.returncode, 0)
        self.assertIn("must be true or false", invalid.stderr)

    def test_normalizes_named_toggle(self) -> None:
        result = self._run(
            'CUSTOM_TOGGLE="$2"; normalize_toggle CUSTOM_TOGGLE false; '
            'printf "%s\\n" "$CUSTOM_TOGGLE"',
            "true",
        )
        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertEqual(result.stdout, "true\n")

    def _run(self, expression: str, value: str) -> subprocess.CompletedProcess[str]:
        return subprocess.run(
            [
                "bash",
                "-Eeuo",
                "pipefail",
                "-c",
                f'source "$1"; {expression}',
                "bash",
                str(ENTRYPOINT_PATH),
                value,
            ],
            check=False,
            capture_output=True,
            encoding="utf-8",
            env={
                "PATH": os.environ.get("PATH", "/usr/bin:/bin"),
                "AUTOGPT_ASSET_DIR": str(ASSET_DIR),
            },
        )


class ValkeyConfigurationTest(unittest.TestCase):
    def test_password_is_kept_out_of_process_arguments(self) -> None:
        entrypoint = ENTRYPOINT_PATH.read_text(encoding="utf-8")
        service_runner = RUN_SERVICE_PATH.read_text(encoding="utf-8")

        self.assertIn("printf 'requirepass %s", entrypoint)
        self.assertIn("printf 'masterauth %s", entrypoint)
        self.assertIn("chmod 0400", entrypoint)
        self.assertNotIn("--requirepass", service_runner)
        self.assertNotIn("--masterauth", service_runner)


class CodexTemporaryHomeTest(unittest.TestCase):
    def test_defaults_to_private_memory_backed_storage(self) -> None:
        entrypoint = ENTRYPOINT_PATH.read_text(encoding="utf-8")
        result = subprocess.run(
            [
                "bash",
                "-Eeuo",
                "pipefail",
                "-c",
                'source "$1"; printf "%s\\n" "$CODEX_TEMP_ROOT"',
                "bash",
                str(ENTRYPOINT_PATH),
            ],
            check=False,
            capture_output=True,
            encoding="utf-8",
            env={
                "PATH": os.environ.get("PATH", "/usr/bin:/bin"),
                "AUTOGPT_ASSET_DIR": str(ASSET_DIR),
                "CODEX_TEMP_ROOT": "/data/not-memory-backed",
            },
        )

        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertEqual(result.stdout, "/dev/shm/autogpt-codex\n")
        self.assertIn(
            'install -d -m 0700 -o autogpt -g autogpt "${CODEX_TEMP_ROOT}"',
            entrypoint,
        )
        self.assertIn('"${CODEX_TEMP_ROOT}"; do', entrypoint)


class ProxyIsolationTest(unittest.TestCase):
    def test_nginx_uses_a_dedicated_operating_system_user(self) -> None:
        dockerfile = DOCKERFILE_PATH.read_text(encoding="utf-8")
        supervisor = SUPERVISOR_PATH.read_text(encoding="utf-8")
        nginx_program = supervisor.split("[program:nginx]", 1)[1].split(
            "[program:watchdog]", 1
        )[0]

        self.assertIn("--uid 10006", dockerfile)
        self.assertIn("user=autogpt_proxy", nginx_program)
        self.assertIn("AUTOGPT_HOME=/run/autogpt/nginx/home", nginx_program)
        self.assertNotIn("user=autogpt\n", nginx_program)


class ThirdPartyTelemetryTest(unittest.TestCase):
    def test_entrypoint_exports_the_vendor_telemetry_opt_outs(self) -> None:
        entrypoint = ENTRYPOINT_PATH.read_text(encoding="utf-8")

        # mem0 and graphiti-core embed their own PostHog write keys and report
        # to their vendors unless these are set. A self-hosted appliance must
        # not send anything to a third party the operator never chose.
        self.assertIn("export MEM0_TELEMETRY=false", entrypoint)
        self.assertIn("export GRAPHITI_TELEMETRY_ENABLED=false", entrypoint)


if __name__ == "__main__":
    unittest.main()