Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

tests/test_resource_limits.py

@@ -0,0 +1,349 @@
+"""Tests for configurable RLIMIT_NOFILE startup handling."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import subprocess
+import sys
+import textwrap
+from types import SimpleNamespace
+
+import pytest
+
+from hermes_cli import resource_limits
+
+
+class _FakeResource:
+    RLIMIT_NOFILE = 7
+    RLIM_INFINITY = 2**63 - 1
+
+    def __init__(self, soft: int, hard: int) -> None:
+        self.limits = (soft, hard)
+        self.set_calls: list[tuple[int, tuple[int, int]]] = []
+
+    def getrlimit(self, resource: int) -> tuple[int, int]:
+        assert resource == self.RLIMIT_NOFILE
+        return self.limits
+
+    def setrlimit(self, resource: int, limits: tuple[int, int]) -> None:
+        assert resource == self.RLIMIT_NOFILE
+        self.set_calls.append((resource, limits))
+        self.limits = limits
+
+
+def test_real_config_loader_reads_runtime_nofile_setting(monkeypatch, tmp_path):
+    """The helper uses the canonical config loader, not a second YAML parser."""
+    home = tmp_path / ".hermes"
+    home.mkdir()
+    (home / "config.yaml").write_text(
+        "runtime:\n  nofile_soft_limit: 2048\n",
+        encoding="utf-8",
+    )
+    fake_resource = _FakeResource(soft=256, hard=4096)
+    monkeypatch.setenv("HERMES_HOME", str(home))
+    monkeypatch.setattr(resource_limits, "_resource", fake_resource)
+
+    assert resource_limits.apply_nofile_soft_limit() is True
+    assert fake_resource.set_calls == [
+        (fake_resource.RLIMIT_NOFILE, (2048, 4096)),
+    ]
+
+
+def test_default_is_clamped_to_hard_limit(monkeypatch):
+    fake_resource = _FakeResource(soft=256, hard=1024)
+    monkeypatch.setattr(resource_limits, "_resource", fake_resource)
+
+    assert resource_limits.apply_nofile_soft_limit({}) is True
+    assert fake_resource.limits == (1024, 1024)
+
+
+def test_finite_soft_limit_raises_when_hard_limit_is_infinite(monkeypatch):
+    fake_resource = _FakeResource(soft=256, hard=_FakeResource.RLIM_INFINITY)
+    monkeypatch.setattr(resource_limits, "_resource", fake_resource)
+
+    assert resource_limits.apply_nofile_soft_limit({}) is True
+    assert fake_resource.set_calls == [
+        (
+            fake_resource.RLIMIT_NOFILE,
+            (4096, fake_resource.RLIM_INFINITY),
+        ),
+    ]
+
+
+def test_never_lowers_an_already_higher_soft_limit(monkeypatch):
+    fake_resource = _FakeResource(soft=8192, hard=16384)
+    monkeypatch.setattr(resource_limits, "_resource", fake_resource)
+
+    assert resource_limits.apply_nofile_soft_limit(
+        {"runtime": {"nofile_soft_limit": 4096}}
+    ) is False
+    assert fake_resource.set_calls == []
+    assert fake_resource.limits == (8192, 16384)
+
+
+@pytest.mark.parametrize("disabled", [0, False, None])
+def test_explicit_values_disable(monkeypatch, disabled):
+    fake_resource = _FakeResource(soft=256, hard=4096)
+    monkeypatch.setattr(resource_limits, "_resource", fake_resource)
+
+    assert resource_limits.apply_nofile_soft_limit(
+        {"runtime": {"nofile_soft_limit": disabled}}
+    ) is False
+    assert fake_resource.set_calls == []
+
+
+def test_unsupported_platform_is_a_safe_noop(monkeypatch):
+    monkeypatch.setattr(resource_limits, "_resource", None)
+
+    assert resource_limits.apply_nofile_soft_limit({}) is False
+
+
+def test_fresh_process_import_without_posix_resource_is_a_safe_noop():
+    code = textwrap.dedent(
+        """
+        import importlib.util
+        import pathlib
+        import sys
+
+        sys.modules["resource"] = None
+        module_path = pathlib.Path(sys.argv[1])
+        spec = importlib.util.spec_from_file_location(
+            "hermes_cli._resource_limits_without_posix_resource",
+            module_path,
+        )
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        assert module._resource is None
+        assert module.apply_nofile_soft_limit({}) is False
+        """
+    )
+
+    subprocess.run(
+        [sys.executable, "-c", code, resource_limits.__file__],
+        check=True,
+        cwd=Path(resource_limits.__file__).resolve().parents[1],
+        capture_output=True,
+        text=True,
+    )
+
+
+@pytest.mark.parametrize("invalid", [True, -1, 4096.0, "4096", object()])
+def test_invalid_values_are_safe_noops(monkeypatch, invalid):
+    fake_resource = _FakeResource(soft=256, hard=4096)
+    monkeypatch.setattr(resource_limits, "_resource", fake_resource)
+
+    assert resource_limits.apply_nofile_soft_limit(
+        {"runtime": {"nofile_soft_limit": invalid}}
+    ) is False
+    assert fake_resource.set_calls == []
+
+
+def test_setrlimit_denial_is_a_safe_noop(monkeypatch):
+    class _DeniedResource(_FakeResource):
+        def setrlimit(self, resource: int, limits: tuple[int, int]) -> None:
+            raise PermissionError("simulated EPERM")
+
+    fake_resource = _DeniedResource(soft=256, hard=4096)
+    monkeypatch.setattr(resource_limits, "_resource", fake_resource)
+
+    assert resource_limits.apply_nofile_soft_limit({}) is False
+    assert fake_resource.limits == (256, 4096)
+
+
+def test_getrlimit_failure_is_a_safe_noop(monkeypatch):
+    class _BrokenResource(_FakeResource):
+        def getrlimit(self, resource: int) -> tuple[int, int]:
+            raise OSError("simulated getrlimit failure")
+
+    fake_resource = _BrokenResource(soft=256, hard=4096)
+    monkeypatch.setattr(resource_limits, "_resource", fake_resource)
+
+    assert resource_limits.apply_nofile_soft_limit({}) is False
+    assert fake_resource.set_calls == []
+
+
+def test_never_lowers_an_unlimited_soft_limit(monkeypatch):
+    fake_resource = _FakeResource(soft=-1, hard=-1)
+    fake_resource.RLIM_INFINITY = -1
+    monkeypatch.setattr(resource_limits, "_resource", fake_resource)
+
+    assert resource_limits.apply_nofile_soft_limit({}) is False
+    assert fake_resource.set_calls == []
+    assert fake_resource.limits == (-1, -1)
+
+
+@pytest.mark.anyio
+async def test_gateway_startup_applies_limit_before_gateway_initialization(monkeypatch):
+    import gateway.code_skew
+    import gateway.run as gateway_run
+
+    calls: list[str] = []
+
+    monkeypatch.setattr(
+        resource_limits,
+        "apply_nofile_soft_limit",
+        lambda: calls.append("limit"),
+    )
+
+    class _StopStartup(Exception):
+        pass
+
+    def stop_after_limit():
+        calls.append("gateway-init")
+        raise _StopStartup
+
+    monkeypatch.setattr(gateway.code_skew, "record_boot_fingerprint", stop_after_limit)
+
+    with pytest.raises(_StopStartup):
+        await gateway_run.start_gateway()
+
+    assert calls == ["limit", "gateway-init"]
+
+
+def test_serve_startup_applies_limit_before_web_server(monkeypatch):
+    from hermes_cli import main as cli_main
+    import hermes_cli.plugins
+    import hermes_cli.web_server
+
+    # cmd_dashboard(headless_backend=True) exports HERMES_SERVE_HEADLESS=1 into
+    # this process's environment (main.py serve path). Touch the key through
+    # monkeypatch FIRST so teardown restores the pre-test state — otherwise the
+    # leaked flag flips later web-server tests (mount_spa) into the headless
+    # 404 path.
+    monkeypatch.setenv("HERMES_SERVE_HEADLESS", "0")
+
+    calls: list[str] = []
+    monkeypatch.setattr(
+        resource_limits,
+        "apply_nofile_soft_limit",
+        lambda: calls.append("limit"),
+    )
+    monkeypatch.setattr(cli_main, "_sync_bundled_skills_quietly", lambda: None)
+    monkeypatch.setattr(cli_main, "_build_web_ui", lambda *args, **kwargs: True)
+    monkeypatch.setattr(cli_main, "_maybe_setup_dashboard_auth_interactively", lambda args: None)
+    monkeypatch.setattr(hermes_cli.plugins, "discover_plugins", lambda: None)
+    monkeypatch.setattr(
+        hermes_cli.web_server,
+        "start_server",
+        lambda **kwargs: calls.append("server"),
+    )
+
+    args = SimpleNamespace(
+        status=False,
+        stop=False,
+        headless_backend=True,
+        ssh_owner_nonce=None,
+        ssh_session_token_file=None,
+        host="127.0.0.1",
+        port=0,
+        no_open=True,
+        insecure=False,
+        open_profile="",
+        isolated=True,
+        skip_build=False,
+    )
+
+    cli_main.cmd_dashboard(args)
+
+    assert calls == ["limit", "server"]
+
+
+def test_named_profile_reroute_defers_limit_to_final_process(monkeypatch, tmp_path):
+    """The launcher profile must not leak its limit across machine re-exec."""
+    from hermes_cli import main as cli_main
+    import hermes_cli.profiles
+    import hermes_constants
+    from tools.environments import local as local_environment
+
+    calls: list[str] = []
+    exec_call: dict[str, object] = {}
+
+    monkeypatch.delenv("HERMES_DESKTOP", raising=False)
+    monkeypatch.setattr(
+        resource_limits,
+        "apply_nofile_soft_limit",
+        lambda: calls.append("limit"),
+    )
+    monkeypatch.setattr(
+        hermes_cli.profiles,
+        "get_active_profile_name",
+        lambda: "worker",
+    )
+    monkeypatch.setattr(cli_main, "_dashboard_listening", lambda *args: False)
+    monkeypatch.setattr(
+        local_environment,
+        "build_subprocess_env",
+        lambda **kwargs: {},
+    )
+    monkeypatch.setattr(
+        hermes_constants,
+        "get_default_hermes_root",
+        lambda: tmp_path,
+    )
+
+    class _ExecCalled(Exception):
+        pass
+
+    def stop_at_exec(executable, argv, env):
+        exec_call.update(executable=executable, argv=argv, env=env)
+        raise _ExecCalled
+
+    monkeypatch.setattr(cli_main.os, "execvpe", stop_at_exec)
+
+    args = SimpleNamespace(
+        status=False,
+        stop=False,
+        headless_backend=True,
+        ssh_owner_nonce=None,
+        ssh_session_token_file=None,
+        host="127.0.0.1",
+        port=0,
+        no_open=True,
+        insecure=False,
+        open_profile="",
+        isolated=False,
+        skip_build=False,
+    )
+
+    with pytest.raises(_ExecCalled):
+        cli_main.cmd_dashboard(args)
+
+    assert calls == []
+    assert exec_call["argv"][1:5] == ["-m", "hermes_cli.main", "-p", "default"]
+    assert exec_call["env"]["HERMES_HOME"] == str(tmp_path)
+
+
+@pytest.mark.parametrize("lifecycle_flag", ["status", "stop"])
+def test_dashboard_lifecycle_flags_skip_limit_adjustment(monkeypatch, lifecycle_flag):
+    """Informational/stop-only commands must not mutate process limits."""
+    from hermes_cli import main as cli_main
+
+    calls: list[str] = []
+    monkeypatch.setattr(
+        resource_limits,
+        "apply_nofile_soft_limit",
+        lambda: calls.append("limit"),
+    )
+    monkeypatch.setattr(cli_main, "_scan_dashboard_processes", lambda: [])
+    monkeypatch.setattr(cli_main, "_find_stale_dashboard_pids", lambda: [])
+
+    args = SimpleNamespace(
+        status=lifecycle_flag == "status",
+        stop=lifecycle_flag == "stop",
+        headless_backend=False,
+        ssh_owner_nonce=None,
+        ssh_session_token_file=None,
+        host="127.0.0.1",
+        port=0,
+        no_open=True,
+        insecure=False,
+        open_profile="",
+        isolated=False,
+        skip_build=False,
+    )
+
+    with pytest.raises(SystemExit):
+        cli_main.cmd_dashboard(args)
+
+    assert calls == []