ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.
Python active-directorycloud-securitydefensive-validationfastapigood-first-issuemitre-attackopsecreactred-teamreportingsecurity
from __future__ import annotations
import importlib.metadata
import os
import re
import sys
import tomllib
import types
from collections import namedtuple
from pathlib import Path
import pytest
import typer
VersionInfo = namedtuple("version_info", "major minor micro releaselevel serial")
def _run_doctor(monkeypatch, tmp_path, capsys) -> str:
from ares.cli.typer_main import doctor
monkeypatch.chdir(tmp_path)
(tmp_path / ".env").write_text("ARES_SECRET_KEY=test\n", encoding="utf-8")
try:
doctor(pdf_smoke=False)
except typer.Exit:
pass
return capsys.readouterr().out
def test_doctor_uses_distribution_metadata_for_impacket(monkeypatch, tmp_path, capsys):
from ares.cli.typer_main import doctor
fake_impacket = types.ModuleType("impacket")
fake_paramiko = types.ModuleType("paramiko")
fake_paramiko.__version__ = "3.4.0"
def fake_version(package_name: str) -> str:
if package_name == "impacket":
return "0.13.1"
raise importlib.metadata.PackageNotFoundError(package_name)
monkeypatch.chdir(tmp_path)
(tmp_path / ".env").write_text("ARES_SECRET_KEY=test\n", encoding="utf-8")
monkeypatch.setattr(importlib.metadata, "version", fake_version)
monkeypatch.setitem(sys.modules, "impacket", fake_impacket)
monkeypatch.setitem(sys.modules, "paramiko", fake_paramiko)
monkeypatch.setitem(sys.modules, "ldap3", None)
doctor(pdf_smoke=False)
output = capsys.readouterr().out
assert "impacket 0.13.1" in output
assert "[WARN] impacket" not in output
assert "too old (0.0.0)" not in output
assert "ad-support" in output
def test_doctor_accepts_supported_impacket_metadata_version(monkeypatch, tmp_path, capsys):
fake_impacket = types.ModuleType("impacket")
def fake_version(package_name: str) -> str:
if package_name == "impacket":
return "0.12.0"
raise importlib.metadata.PackageNotFoundError(package_name)
monkeypatch.setattr(importlib.metadata, "version", fake_version)
monkeypatch.setitem(sys.modules, "impacket", fake_impacket)
output = _run_doctor(monkeypatch, tmp_path, capsys)
assert "impacket 0.12.0" in output
assert ">= 0.11 required" in output
assert "[WARN] impacket" not in output
assert "installed, but version could not be detected" not in output
def test_doctor_warns_for_too_old_impacket_metadata_version(monkeypatch, tmp_path, capsys):
fake_impacket = types.ModuleType("impacket")
def fake_version(package_name: str) -> str:
if package_name == "impacket":
return "0.10.0"
raise importlib.metadata.PackageNotFoundError(package_name)
monkeypatch.setattr(importlib.metadata, "version", fake_version)
monkeypatch.setitem(sys.modules, "impacket", fake_impacket)
output = _run_doctor(monkeypatch, tmp_path, capsys)
assert "[WARN] impacket 0.10.0" in output
assert ">= 0.11" in output
assert "installed, but version could not be detected" not in output
def test_doctor_accepts_impacket_source_version_attribute(monkeypatch, tmp_path, capsys):
fake_impacket = types.ModuleType("impacket")
fake_impacket.__version__ = "0.12.0"
def fake_version(package_name: str) -> str:
raise importlib.metadata.PackageNotFoundError(package_name)
monkeypatch.setattr(importlib.metadata, "version", fake_version)
monkeypatch.setitem(sys.modules, "impacket", fake_impacket)
monkeypatch.delitem(sys.modules, "impacket.version", raising=False)
output = _run_doctor(monkeypatch, tmp_path, capsys)
assert "impacket 0.12.0" in output
assert "[WARN] impacket" not in output
assert "installed, but version could not be detected" not in output
def test_doctor_accepts_impacket_version_banner(monkeypatch, tmp_path, capsys):
fake_impacket = types.ModuleType("impacket")
fake_version_module = types.ModuleType("impacket.version")
fake_version_module.BANNER = "Impacket v0.12.0"
fake_impacket.version = fake_version_module
def fake_version(package_name: str) -> str:
raise importlib.metadata.PackageNotFoundError(package_name)
monkeypatch.setattr(importlib.metadata, "version", fake_version)
monkeypatch.setitem(sys.modules, "impacket", fake_impacket)
monkeypatch.setitem(sys.modules, "impacket.version", fake_version_module)
output = _run_doctor(monkeypatch, tmp_path, capsys)
assert "impacket 0.12.0" in output
assert "[WARN] impacket" not in output
assert "installed, but version could not be detected" not in output
def test_doctor_accepts_importable_impacket_with_unknown_version(monkeypatch, tmp_path, capsys):
fake_impacket = types.ModuleType("impacket")
def fake_version(package_name: str) -> str:
raise importlib.metadata.PackageNotFoundError(package_name)
monkeypatch.setattr(importlib.metadata, "version", fake_version)
monkeypatch.setitem(sys.modules, "impacket", fake_impacket)
monkeypatch.delitem(sys.modules, "impacket.version", raising=False)
output = _run_doctor(monkeypatch, tmp_path, capsys)
normalized = " ".join(output.split())
assert "[OK] impacket (AD/SMB modules)" in output
assert "version unknown from source/local install" in normalized
assert "[WARN] impacket" not in output
assert "installed, but version could not be detected" not in output
def test_doctor_warns_when_impacket_import_fails(monkeypatch, tmp_path, capsys):
def fake_version(package_name: str) -> str:
raise importlib.metadata.PackageNotFoundError(package_name)
monkeypatch.setattr(importlib.metadata, "version", fake_version)
monkeypatch.setitem(sys.modules, "impacket", None)
monkeypatch.delitem(sys.modules, "impacket.version", raising=False)
output = _run_doctor(monkeypatch, tmp_path, capsys)
assert "[WARN] impacket" in output
assert '".[ad]"' in output
assert "installed, but version could not be detected" not in output
def test_doctor_warns_for_missing_direct_ad_support_dependencies(
monkeypatch, tmp_path, capsys
):
fake_impacket = types.ModuleType("impacket")
def fake_version(package_name: str) -> str:
if package_name == "impacket":
return "0.13.1"
raise importlib.metadata.PackageNotFoundError(package_name)
monkeypatch.setattr(importlib.metadata, "version", fake_version)
monkeypatch.setitem(sys.modules, "impacket", fake_impacket)
for import_name in ("pyasn1", "pyasn1_modules", "ldap3", "httpx_ntlm"):
monkeypatch.setitem(sys.modules, import_name, None)
output = _run_doctor(monkeypatch, tmp_path, capsys)
normalized = " ".join(output.split())
assert "[WARN] pyasn1 (AD Kerberos helpers)" in output
assert "[WARN] pyasn1_modules (AD Kerberos helpers)" in output
assert "[WARN] ldap3" in output
assert "[WARN] httpx-ntlm (ad.adcs ESC1)" in output
assert "install -e \".[ad]\"" in normalized
assert "install -e \".[ad-support]\"" in normalized
assert "restart the dashboard" in normalized
def test_pyproject_exposes_ad_support_extra_for_source_impacket_users():
pyproject = tomllib.loads(Path("pyproject.toml").read_text(encoding="utf-8"))
extras = pyproject["project"]["optional-dependencies"]
assert "ad-support" in extras
assert {"pyasn1>=0.5", "pyasn1-modules>=0.3", "ldap3>=2.9", "httpx-ntlm>=1.4"} <= set(
extras["ad-support"]
)
assert {"pyasn1>=0.5", "pyasn1-modules>=0.3"} <= set(extras["ad"])
def test_docs_mention_ad_support_extra_for_source_impacket_users():
docs = "\n".join(
Path(path).read_text(encoding="utf-8")
for path in ("README.md", "QUICKSTART.md", "docs/modules.md")
)
assert ".[ad-support]" in docs
assert "source/local" in docs
assert "Impacket" in docs
assert "pyasn1_modules" in docs
def test_doctor_reports_broken_optional_import_and_continues(monkeypatch, tmp_path, capsys):
import importlib
from ares.cli.typer_main import doctor
real_import_module = importlib.import_module
fake_impacket = types.ModuleType("impacket")
fake_impacket.__version__ = "0.13.1"
def fake_version(package_name: str) -> str:
if package_name == "impacket":
return "0.13.1"
raise importlib.metadata.PackageNotFoundError(package_name)
def fake_import_module(import_name: str, package: str | None = None):
if import_name == "impacket":
raise OSError(22, "Invalid argument")
return real_import_module(import_name, package)
monkeypatch.chdir(tmp_path)
(tmp_path / ".env").write_text("ARES_SECRET_KEY=test\n", encoding="utf-8")
monkeypatch.setitem(sys.modules, "impacket", fake_impacket)
monkeypatch.setattr(importlib.metadata, "version", fake_version)
monkeypatch.setattr(importlib, "import_module", fake_import_module)
try:
doctor(pdf_smoke=False)
except typer.Exit:
pass
output = capsys.readouterr().out
assert "Traceback" not in output
assert "impacket" in output
assert "OSError" in output
assert "Invalid argument" in output
assert "paramiko" in output
assert "socket AF_INET/389" in output
def test_doctor_guides_windows_ad_impacket_to_python_312(monkeypatch, tmp_path, capsys):
from ares.cli.typer_main import doctor
monkeypatch.chdir(tmp_path)
(tmp_path / ".env").write_text("ARES_SECRET_KEY=test\n", encoding="utf-8")
monkeypatch.setattr(sys, "version_info", VersionInfo(3, 11, 9, "final", 0))
try:
doctor(pdf_smoke=False)
except typer.Exit:
pass
output = capsys.readouterr().out
assert "Python 3.11.9" in output
assert "Package metadata permits Python 3.11-3.12" in output
normalized = " ".join(output.split())
assert "Windows AD/Impacket" in normalized
assert "Python 3.12" in normalized
assert "Windows AD/Impacket Python" in output
assert "Python 3.12.x" in output
def test_doctor_reports_pdf_capability(monkeypatch, tmp_path, capsys):
from ares.cli.typer_main import doctor
from ares.modules.reporting import report_gen
browser = tmp_path / "chrome.exe"
browser.write_text("", encoding="utf-8")
fake_weasyprint = types.ModuleType("weasyprint")
fake_weasyprint.__version__ = "test-pdf"
class FakeReportGenerator:
def __init__(self) -> None:
self.output_dir = tmp_path / "reports"
self.output_dir.mkdir(parents=True, exist_ok=True)
@staticmethod
def _pdf_browser_candidates() -> list[Path]:
return [browser]
@staticmethod
def _probe_writable_dir(path: Path) -> None:
path.mkdir(parents=True, exist_ok=True)
probe = path / ".probe"
probe.write_text("ok", encoding="utf-8")
probe.unlink()
def _create_pdf_browser_workspace(self) -> tuple[Path, Path, Path]:
work_path = tmp_path / "pdf-work"
profile_dir = work_path / "profile"
profile_dir.mkdir(parents=True, exist_ok=True)
return work_path, profile_dir, work_path / "report.html"
@staticmethod
def _windows_session_is_elevated() -> bool:
return False
def _pdf_browser_skip_reason(self, browser: Path) -> str:
return ""
def _run_pdf_browser(self, cmd: list[str]): # pragma: no cover - must not run
raise AssertionError("doctor must not launch a PDF browser")
monkeypatch.chdir(tmp_path)
(tmp_path / ".env").write_text("ARES_SECRET_KEY=test\n", encoding="utf-8")
monkeypatch.setenv("ARES_PDF_BROWSER", str(browser))
monkeypatch.setitem(sys.modules, "weasyprint", fake_weasyprint)
monkeypatch.setattr(report_gen, "ReportGenerator", FakeReportGenerator)
try:
doctor(pdf_smoke=False)
except typer.Exit:
pass
output = capsys.readouterr().out
assert "PDF WeasyPrint" in output
assert "test-pdf" in output
assert "PDF ARES_PDF_BROWSER" in output
assert "chrome.exe" in output
assert "exists=True" in output
assert "PDF browser detected" in output
assert "PDF browser profile temp dir writable" in output
assert "PDF report output dir writable" in output
def test_doctor_reports_windows_weasyprint_native_dependency_hint(
monkeypatch, tmp_path, capsys
):
import importlib
from ares.cli.typer_main import doctor
from ares.modules.reporting import report_gen
from ares.modules.reporting.report_gen import WINDOWS_WEASYPRINT_NATIVE_HINT
real_import_module = importlib.import_module
browser = tmp_path / "msedge.exe"
browser.write_text("", encoding="utf-8")
class FakeReportGenerator:
def __init__(self) -> None:
self.output_dir = tmp_path / "reports"
self.output_dir.mkdir(parents=True, exist_ok=True)
@staticmethod
def _pdf_browser_candidates() -> list[Path]:
return [browser]
@staticmethod
def _pdf_backend_failure_detail(exc: BaseException) -> str:
return f"{WINDOWS_WEASYPRINT_NATIVE_HINT} Original error: {exc}"
@staticmethod
def _probe_writable_dir(path: Path) -> None:
path.mkdir(parents=True, exist_ok=True)
probe = path / ".probe"
probe.write_text("ok", encoding="utf-8")
probe.unlink()
@staticmethod
def _windows_session_is_elevated() -> bool:
return False
def _pdf_browser_skip_reason(self, browser: Path) -> str:
return ""
def _create_pdf_browser_workspace(self) -> tuple[Path, Path, Path]:
work_path = tmp_path / "pdf-work"
profile_dir = work_path / "profile"
profile_dir.mkdir(parents=True, exist_ok=True)
return work_path, profile_dir, work_path / "report.html"
def fake_import_module(import_name: str, package: str | None = None):
if import_name == "weasyprint":
raise OSError("cannot load library 'libgobject-2.0-0'")
return real_import_module(import_name, package)
monkeypatch.chdir(tmp_path)
(tmp_path / ".env").write_text("ARES_SECRET_KEY=test\n", encoding="utf-8")
monkeypatch.setattr(report_gen, "ReportGenerator", FakeReportGenerator)
monkeypatch.setattr(importlib, "import_module", fake_import_module)
try:
doctor(pdf_smoke=False)
except typer.Exit:
pass
output = capsys.readouterr().out
assert "PDF WeasyPrint" in output
assert "native GTK/Pango" in output
assert "libgobject-2.0-0" in output
def test_doctor_pdf_smoke_uses_report_generator_and_verifies_pdf(
tmp_path, capsys
):
from ares.cli.typer_main import _run_pdf_smoke_check
calls = {"smoke": 0}
records: list[tuple[str, str, str]] = []
class FakeReportGenerator:
def __init__(self) -> None:
self.output_dir = tmp_path / "reports"
self.output_dir.mkdir(parents=True, exist_ok=True)
def generate_pdf_smoke(self) -> Path:
calls["smoke"] += 1
smoke_path = self.output_dir / "ares_pdf_smoke.pdf"
smoke_path.write_bytes(b"%PDF-1.4\n% smoke\n")
return smoke_path
def fake_check(label: str, status: str, detail: str = "") -> None:
records.append((label, status, detail))
print(f"[{status.upper()}] {label} {detail}")
_run_pdf_smoke_check(FakeReportGenerator(), fake_check)
output = capsys.readouterr().out
assert "PDF smoke" in output
assert "ares_pdf_smoke.pdf" in output
assert "[OK] PDF smoke" in output
assert "bytes=" in output
assert calls == {"smoke": 1}
assert records[0][0] == "PDF smoke"
assert records[0][1] == "ok"
def test_pdf_smoke_check_reports_invalid_pdf_artifact(tmp_path, capsys):
from ares.cli.typer_main import _run_pdf_smoke_check
records: list[tuple[str, str, str]] = []
class FakeReportGenerator:
def generate_pdf_smoke(self) -> Path:
smoke_path = tmp_path / "ares_pdf_smoke.pdf"
smoke_path.write_bytes(b"not-a-pdf\n")
return smoke_path
def fake_check(label: str, status: str, detail: str = "") -> None:
records.append((label, status, detail))
print(f"[{status.upper()}] {label} {detail}")
_run_pdf_smoke_check(FakeReportGenerator(), fake_check)
output = capsys.readouterr().out
assert "PDF smoke" in output
assert "ares_pdf_smoke.pdf" in output
assert "[FAIL] PDF smoke" in output
assert "not a PDF" in output
assert records == [
("PDF smoke", "fail", f"{tmp_path / 'ares_pdf_smoke.pdf'} is not a PDF")
]
def test_doctor_pdf_smoke_option_calls_helper(monkeypatch, tmp_path):
import importlib
from ares.cli import typer_main
from ares.modules.reporting import report_gen
calls = {"helper": 0}
real_import_module = importlib.import_module
browser = tmp_path / "msedge.exe"
browser.write_text("", encoding="utf-8")
fake_weasyprint = types.ModuleType("weasyprint")
fake_weasyprint.__version__ = "test-pdf"
class FakeReportGenerator:
def __init__(self) -> None:
self.output_dir = tmp_path / "reports"
self.output_dir.mkdir(parents=True, exist_ok=True)
@staticmethod
def _pdf_browser_candidates() -> list[Path]:
return [browser]
@staticmethod
def _probe_writable_dir(path: Path) -> None:
path.mkdir(parents=True, exist_ok=True)
probe = path / ".probe"
probe.write_text("ok", encoding="utf-8")
probe.unlink()
@staticmethod
def _windows_session_is_elevated() -> bool:
return False
def _pdf_browser_skip_reason(self, browser: Path) -> str:
return ""
def _create_pdf_browser_workspace(self) -> tuple[Path, Path, Path]:
work_path = tmp_path / "pdf-work"
profile_dir = work_path / "profile"
profile_dir.mkdir(parents=True, exist_ok=True)
return work_path, profile_dir, work_path / "report.html"
def _run_pdf_browser(self, cmd: list[str]): # pragma: no cover - must not run
raise AssertionError("doctor must not launch a PDF browser directly")
def fake_import_module(import_name: str, package: str | None = None):
if import_name == "weasyprint":
return fake_weasyprint
return real_import_module(import_name, package)
def fake_pdf_smoke_check(pdf_generator: object, check: object) -> None:
calls["helper"] += 1
assert isinstance(pdf_generator, FakeReportGenerator)
monkeypatch.chdir(tmp_path)
(tmp_path / ".env").write_text("ARES_SECRET_KEY=test\n", encoding="utf-8")
monkeypatch.setattr(report_gen, "ReportGenerator", FakeReportGenerator)
monkeypatch.setattr(importlib, "import_module", fake_import_module)
monkeypatch.setattr(typer_main, "_run_pdf_smoke_check", fake_pdf_smoke_check)
try:
typer_main.doctor(pdf_smoke=True)
except typer.Exit:
pass
assert calls == {"helper": 1}
def test_setup_entrypoint_routes_to_python_native_setup(monkeypatch):
from ares.cli import typer_main
calls = []
monkeypatch.setattr(typer_main, "_run_python_setup", lambda: calls.append("called"))
typer_main.setup_entrypoint()
assert calls == ["called"]
def test_python_setup_windows_skips_bash_and_uses_valid_paths(monkeypatch, tmp_path, capsys):
from ares.cli.typer_main import _run_python_setup
(tmp_path / "scripts").mkdir()
(tmp_path / "scripts" / "setup.sh").write_text("#!/usr/bin/env bash\n", encoding="utf-8")
(tmp_path / ".env.example").write_text(
"ARES_SECRET_KEY=\nARES_ENCRYPTION_KEY=\nARES_DEFAULT_ADMIN_PASSWORD=\n",
encoding="utf-8",
)
def forbidden_execv(*args):
raise AssertionError("ares-setup must not exec bash")
monkeypatch.setattr(os, "execv", forbidden_execv)
_run_python_setup(
root=tmp_path,
platform_name="win32",
os_name="nt",
version_info=VersionInfo(3, 12, 0, "final", 0),
)
output = capsys.readouterr().out
assert "ARES Setup" in output
assert "Windows" in output
assert "scripts/setup.sh is POSIX-only and was skipped on Windows" in output
assert "/bin/bash" not in output
assert "C:Users" not in output
assert (tmp_path / ".env").exists()
def test_python_setup_posix_keeps_shell_helper_optional(tmp_path, capsys):
from ares.cli.typer_main import _run_python_setup
(tmp_path / "scripts").mkdir()
(tmp_path / "scripts" / "setup.sh").write_text("#!/usr/bin/env bash\n", encoding="utf-8")
(tmp_path / ".env.example").write_text(
"ARES_SECRET_KEY=\nARES_ENCRYPTION_KEY=\nARES_DEFAULT_ADMIN_PASSWORD=\n",
encoding="utf-8",
)
_run_python_setup(
root=tmp_path,
platform_name="linux",
os_name="posix",
version_info=VersionInfo(3, 12, 0, "final", 0),
)
output = capsys.readouterr().out
assert "Linux" in output
assert "Developer helper available: scripts/setup.sh (optional)." in output
assert "/bin/bash" not in output
assert (tmp_path / ".env").exists()
def test_python_setup_rejects_python_313_before_writing_env(tmp_path, capsys):
from ares.cli.typer_main import _run_python_setup
(tmp_path / ".env.example").write_text(
"ARES_SECRET_KEY=\nARES_ENCRYPTION_KEY=\nARES_DEFAULT_ADMIN_PASSWORD=\n",
encoding="utf-8",
)
with pytest.raises(SystemExit):
_run_python_setup(
root=tmp_path,
platform_name="win32",
os_name="nt",
version_info=VersionInfo(3, 13, 0, "final", 0),
)
output = capsys.readouterr().out
assert "Python: 3.13.0" in output
assert "Python 3.11-3.12 is required" in output
assert "Python 3.12.x" in output
assert not (tmp_path / ".env").exists()
def test_python_setup_replaces_change_me_placeholders_in_existing_env(tmp_path, capsys):
from ares.cli.typer_main import _run_python_setup
(tmp_path / ".env").write_text(
"ARES_SECRET_KEY=CHANGE_ME_USE_openssl_rand_-hex_32\n"
"ARES_ENCRYPTION_KEY=CHANGE_ME_USE_Fernet_generate_key\n"
"ARES_DEFAULT_ADMIN_PASSWORD=YOUR_STRONG_ADMIN_PASSWORD_HERE\n"
"ARES_API_PORT=8080\n",
encoding="utf-8",
)
_run_python_setup(
root=tmp_path,
platform_name="win32",
os_name="nt",
version_info=VersionInfo(3, 12, 0, "final", 0),
)
output = capsys.readouterr().out
assert "Replaced CHANGE_ME placeholders in .env with secure generated keys" in output
# AUDIT run-1 H11: the generated admin password must NOT be printed to stdout.
assert "Admin password:" not in output
env_content = (tmp_path / ".env").read_text(encoding="utf-8")
assert "CHANGE_ME" not in env_content
assert "YOUR_STRONG_ADMIN_PASSWORD_HERE" not in env_content
assert "ARES_API_PORT=8080" in env_content
admin_pw = re.search(
r"^ARES_DEFAULT_ADMIN_PASSWORD=(.+)$", env_content, re.MULTILINE
).group(1).strip()
assert admin_pw and admin_pw not in output
def test_python_setup_replaces_new_256bit_placeholder_in_existing_env(tmp_path, capsys):
from ares.cli.typer_main import _run_python_setup
(tmp_path / ".env").write_text(
"ARES_SECRET_KEY=CHANGE_ME_USE_openssl_rand_-hex_32\n"
"ARES_ENCRYPTION_KEY=CHANGE_ME_USE_secrets_token_urlsafe_32\n"
"ARES_DEFAULT_ADMIN_PASSWORD=YOUR_STRONG_ADMIN_PASSWORD_HERE\n"
"ARES_API_PORT=8080\n",
encoding="utf-8",
)
_run_python_setup(
root=tmp_path,
platform_name="win32",
os_name="nt",
version_info=VersionInfo(3, 12, 0, "final", 0),
)
output = capsys.readouterr().out
assert "Replaced CHANGE_ME placeholders in .env with secure generated keys" in output
# AUDIT run-1 H11: the generated admin password must NOT be printed to stdout.
assert "Admin password:" not in output
env_content = (tmp_path / ".env").read_text(encoding="utf-8")
assert "CHANGE_ME" not in env_content
assert "YOUR_STRONG_ADMIN_PASSWORD_HERE" not in env_content
assert "ARES_API_PORT=8080" in env_content
admin_pw = re.search(
r"^ARES_DEFAULT_ADMIN_PASSWORD=(.+)$", env_content, re.MULTILINE
).group(1).strip()
assert admin_pw and admin_pw not in output
def test_python_setup_leaves_configured_env_unchanged(tmp_path, capsys):
from ares.cli.typer_main import _run_python_setup
original = (
"ARES_SECRET_KEY=0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\n"
"ARES_ENCRYPTION_KEY=dGVzdF9rZXlfdGhhdF9pc18zMl9ieXRlc19sb25nISE=\n"
"ARES_DEFAULT_ADMIN_PASSWORD=CustomAdminPassword123!\n"
)
(tmp_path / ".env").write_text(original, encoding="utf-8")
_run_python_setup(
root=tmp_path,
platform_name="win32",
os_name="nt",
version_info=VersionInfo(3, 12, 0, "final", 0),
)
output = capsys.readouterr().out
assert ".env already exists; leaving it unchanged" in output
env_content = (tmp_path / ".env").read_text(encoding="utf-8")
assert env_content == original
def test_python_setup_force_regenerates_existing_env(tmp_path, capsys):
from ares.cli.typer_main import _run_python_setup
original = (
"ARES_SECRET_KEY=old_secret\n"
"ARES_ENCRYPTION_KEY=old_enc\n"
"ARES_DEFAULT_ADMIN_PASSWORD=old_pass\n"
"CUSTOM_VAR=keep_me\n"
)
(tmp_path / ".env").write_text(original, encoding="utf-8")
_run_python_setup(
root=tmp_path,
platform_name="win32",
os_name="nt",
version_info=VersionInfo(3, 12, 0, "final", 0),
force=True,
)
output = capsys.readouterr().out
assert ".env regenerated with fresh secure keys (--force)" in output
# AUDIT run-1 H11: the generated admin password must NOT be printed to stdout.
assert "Admin password:" not in output
env_content = (tmp_path / ".env").read_text(encoding="utf-8")
assert "old_secret" not in env_content
assert "CUSTOM_VAR=keep_me" in env_content
admin_pw = re.search(
r"^ARES_DEFAULT_ADMIN_PASSWORD=(.+)$", env_content, re.MULTILINE
).group(1).strip()
assert admin_pw and admin_pw not in output
def test_setup_entrypoint_parses_force(monkeypatch):
import ares.cli.typer_main as typer_main
calls = []
monkeypatch.setattr(typer_main, "_run_python_setup", lambda force=False: calls.append(force))
monkeypatch.setattr(sys, "argv", ["ares-setup", "--force"])
typer_main.setup_entrypoint()
assert calls == [True]
def test_setup_entrypoint_help(monkeypatch, capsys):
import ares.cli.typer_main as typer_main
monkeypatch.setattr(sys, "argv", ["ares-setup", "--help"])
typer_main.setup_entrypoint()
output = capsys.readouterr().out
assert "Usage: ares-setup" in output
assert "--force" in output
def test_python_setup_cleans_invalid_browser_origin_placeholder(tmp_path, capsys):
from ares.cli.typer_main import _run_python_setup
(tmp_path / ".env").write_text(
"ARES_SECRET_KEY=CHANGE_ME\n"
"ARES_ENCRYPTION_KEY=CHANGE_ME\n"
"ARES_DEFAULT_ADMIN_PASSWORD=YOUR_STRONG_ADMIN_PASSWORD_HERE\n"
"ARES_DEBUG=false\n"
"ARES_BROWSER_ORIGIN=https://ares.example.invalid\n",
encoding="utf-8",
)
_run_python_setup(
root=tmp_path,
platform_name="win32",
os_name="nt",
version_info=VersionInfo(3, 12, 0, "final", 0),
)
content = (tmp_path / ".env").read_text(encoding="utf-8")
assert "example.invalid" not in content
assert "ARES_BROWSER_ORIGIN=" in content
assert "ARES_DEBUG=true" in content
def test_doctor_validates_browser_session_policy(monkeypatch, capsys):
import ares.cli.typer_main as tm
from ares.core.browser_sessions import BrowserSessionPolicy
# Test OK path
fake_policy = BrowserSessionPolicy(
origin="http://127.0.0.1:5173",
authority="127.0.0.1:5173",
refresh_cookie_name="ares-dev-refresh",
csrf_cookie_name="ares-dev-csrf",
secure=False,
debug=True,
)
monkeypatch.setattr(
"ares.core.browser_sessions.build_browser_session_policy",
lambda settings: fake_policy,
)
console_out = []
monkeypatch.setattr(tm.console, "print", lambda *args, **kwargs: console_out.append(str(args)))
try:
tm.doctor()
except typer.Exit:
pass
assert any("Browser session policy" in line and "[OK]" in line for line in console_out)
# Test WARN path when browser session policy cannot be built
from unittest.mock import MagicMock
console_out.clear()
monkeypatch.setattr(
"ares.core.browser_sessions.build_browser_session_policy",
MagicMock(side_effect=ValueError("origin mismatch in production")),
)
try:
tm.doctor()
except typer.Exit:
pass
assert any(
"Browser session policy" in line and "[WARN]" in line and "origin mismatch in production" in line
for line in console_out
)