Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Daylily-Informatics_bloom /tests /test_cli.py
| """Tests for the Bloom CLI surface and Bloom-specific config/server wiring.""" | |
| from __future__ import annotations | |
| import importlib | |
| import json | |
| from pathlib import Path | |
| from types import SimpleNamespace | |
| import pytest | |
| from typer.testing import CliRunner | |
| import bloom_lims.cli as cli_module | |
| from bloom_lims.cli import ( | |
| _enforce_conda_env_contract, | |
| _strip_skip_conda_env_check_flag, | |
| build_app, | |
| config_extra, | |
| ) | |
| from bloom_lims.config import get_user_config_path | |
| try: | |
| from cli_core_yo.certs import ResolvedHttpsCerts | |
| except ImportError: | |
| from dataclasses import dataclass | |
| class ResolvedHttpsCerts: | |
| cert_path: Path | |
| key_path: Path | |
| source: str = "ensure_certs" | |
| server_commands = importlib.import_module("bloom_lims.cli.server") | |
| def runner() -> CliRunner: | |
| return CliRunner() | |
| def cli_app(monkeypatch: pytest.MonkeyPatch, tmp_path: Path): | |
| from bloom_lims.config import get_settings | |
| monkeypatch.setenv("HOME", str(tmp_path)) | |
| monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / ".config")) | |
| monkeypatch.setenv("XDG_STATE_HOME", str(tmp_path / ".local" / "state")) | |
| get_settings.cache_clear() | |
| app = build_app() | |
| yield app | |
| get_settings.cache_clear() | |
| class TestMainCommands: | |
| def test_cli_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["--help"]) | |
| assert result.exit_code == 0 | |
| assert "│ server" in result.output | |
| assert "│ config" in result.output | |
| assert "│ env" in result.output | |
| assert "│ db" in result.output | |
| assert "│ gui" not in result.output | |
| assert "│ doctor" not in result.output | |
| assert "│ status" not in result.output | |
| assert "│ logs" not in result.output | |
| assert "│ shell" not in result.output | |
| def test_removed_root_aliases( | |
| self, runner: CliRunner, cli_app, argv: list[str] | |
| ) -> None: | |
| result = runner.invoke(cli_app, argv) | |
| assert result.exit_code != 0 | |
| assert "No such command" in result.output | |
| def test_version_command(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["version"]) | |
| assert result.exit_code == 0 | |
| assert "BLOOM LIMS" in result.output | |
| def test_info_command(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["info"]) | |
| assert result.exit_code == 0 | |
| assert "Project Root" in result.output | |
| assert "Dev Server" in result.output | |
| def test_env_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["env", "--help"]) | |
| assert result.exit_code == 0 | |
| for command in ["status", "activate", "deactivate", "reset"]: | |
| assert command in result.output | |
| def test_config_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["config", "--help"]) | |
| assert result.exit_code == 0 | |
| for command in [ | |
| "path", | |
| "init", | |
| "show", | |
| "validate", | |
| "edit", | |
| "reset", | |
| "shell", | |
| "doctor", | |
| "status", | |
| ]: | |
| assert command in result.output | |
| def test_server_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["server", "--help"]) | |
| assert result.exit_code == 0 | |
| for command in ["start", "stop", "status", "logs"]: | |
| assert command in result.output | |
| def test_db_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["db", "--help"]) | |
| assert result.exit_code == 0 | |
| assert "build" in result.output | |
| assert "seed" in result.output | |
| assert "reset" in result.output | |
| assert "nuke" in result.output | |
| assert "start" not in result.output | |
| assert "stop" not in result.output | |
| assert "status" not in result.output | |
| assert "migrate" not in result.output | |
| assert "shell" not in result.output | |
| assert "auth-setup" not in result.output | |
| def test_quality_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["quality", "--help"]) | |
| assert result.exit_code == 0 | |
| assert "check" in result.output | |
| def test_users_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["users", "--help"]) | |
| assert result.exit_code == 0 | |
| assert "issue-token" in result.output | |
| assert "list" not in result.output | |
| assert "add" not in result.output | |
| def test_integrations_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["integrations", "--help"]) | |
| assert result.exit_code == 0 | |
| def test_cli_requires_hyphenated_conda_env( | |
| self, monkeypatch: pytest.MonkeyPatch | |
| ) -> None: | |
| monkeypatch.setenv("CONDA_DEFAULT_ENV", "BLOOM") | |
| with pytest.raises( | |
| SystemExit, match="deployment-scoped conda environment name with '-'" | |
| ): | |
| _enforce_conda_env_contract(["db", "init"]) | |
| def test_cli_requires_active_conda_env( | |
| self, monkeypatch: pytest.MonkeyPatch | |
| ) -> None: | |
| monkeypatch.delenv("CONDA_DEFAULT_ENV", raising=False) | |
| with pytest.raises( | |
| SystemExit, match="requires an active deployment-scoped conda environment" | |
| ): | |
| _enforce_conda_env_contract(["db", "init"]) | |
| def test_cli_accepts_hyphenated_conda_env( | |
| self, monkeypatch: pytest.MonkeyPatch | |
| ) -> None: | |
| monkeypatch.setenv("CONDA_DEFAULT_ENV", "BLOOM-local2") | |
| _enforce_conda_env_contract(["db", "init"]) | |
| def test_cli_skip_conda_env_check_flag_is_stripped(self) -> None: | |
| args, skip = _strip_skip_conda_env_check_flag( | |
| ["--skip-conda-env-check", "db", "init"] | |
| ) | |
| assert skip is True | |
| assert args == ["db", "init"] | |
| def test_cli_env_commands_are_exempt_from_conda_env_check( | |
| self, monkeypatch: pytest.MonkeyPatch | |
| ) -> None: | |
| monkeypatch.delenv("CONDA_DEFAULT_ENV", raising=False) | |
| _enforce_conda_env_contract(["env", "status"]) | |
| def test_env_commands_render( | |
| self, runner: CliRunner, cli_app, monkeypatch: pytest.MonkeyPatch | |
| ) -> None: | |
| monkeypatch.setenv("BLOOM_ACTIVE", "1") | |
| monkeypatch.setenv("BLOOM_ROOT", "/tmp/bloom") | |
| status_result = runner.invoke(cli_app, ["env", "status"]) | |
| assert status_result.exit_code == 0 | |
| assert "active" in status_result.output.lower() | |
| assert "/tmp/bloom" in status_result.output | |
| activate_result = runner.invoke(cli_app, ["env", "activate"]) | |
| assert activate_result.exit_code == 0 | |
| assert ( | |
| f"source {cli_module.ACTIVATE_SCRIPT} <deploy-name>" | |
| in activate_result.output | |
| ) | |
| deactivate_result = runner.invoke(cli_app, ["env", "deactivate"]) | |
| assert deactivate_result.exit_code == 0 | |
| assert f"source {cli_module.DEACTIVATE_SCRIPT}" in deactivate_result.output | |
| reset_result = runner.invoke(cli_app, ["env", "reset"]) | |
| assert reset_result.exit_code == 0 | |
| assert f"source {cli_module.DEACTIVATE_SCRIPT}" in reset_result.output | |
| assert ( | |
| f"source {cli_module.ACTIVATE_SCRIPT} <deploy-name>" in reset_result.output | |
| ) | |
| def test_config_doctor_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["config", "doctor", "--help"]) | |
| assert result.exit_code == 0 | |
| def test_config_status_prints_deploy_name( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| monkeypatch: pytest.MonkeyPatch, | |
| ) -> None: | |
| monkeypatch.setenv("BLOOM_DEPLOYMENT_CODE", "bringup") | |
| result = runner.invoke(cli_app, ["config", "status"]) | |
| assert result.exit_code == 0 | |
| assert "deploy-name" in result.output | |
| assert "bringup" in result.output | |
| def test_config_doctor_reports_schema_drift_without_failing( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| monkeypatch: pytest.MonkeyPatch, | |
| tmp_path: Path, | |
| ) -> None: | |
| import bloom_lims.schema_drift as schema_drift_module | |
| state_dir = tmp_path / ".local" / "state" / "bloom" | |
| monkeypatch.setattr(schema_drift_module, "_state_dir", lambda: state_dir) | |
| monkeypatch.setattr( | |
| config_extra, | |
| "run_schema_drift_check", | |
| lambda target_label: { | |
| "status": "drift", | |
| "checked_at": "2026-03-29T12:00:00+00:00", | |
| "target": target_label, | |
| "tool_version": "3.0.9", | |
| "summary": "expected=12 live=13", | |
| "report": {"counts": {"expected": 12, "live": 13}}, | |
| "stderr": "", | |
| }, | |
| ) | |
| monkeypatch.setattr(config_extra, "validate_settings", lambda: []) | |
| monkeypatch.setattr(config_extra, "assert_tapdb_version", lambda: "3.0.9") | |
| result = runner.invoke(cli_app, ["config", "doctor"]) | |
| assert result.exit_code == 0 | |
| assert "schema drift detected" in result.output.lower() | |
| assert "report only" in result.output.lower() | |
| drift_report = schema_drift_module.schema_drift_state_file() | |
| assert drift_report.exists() | |
| assert "expected=12 live=13" in drift_report.read_text(encoding="utf-8") | |
| def test_config_doctor_expects_deployment_scoped_conda_env( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| monkeypatch: pytest.MonkeyPatch, | |
| ) -> None: | |
| monkeypatch.setenv("BLOOM_DEPLOYMENT_CODE", "bringup") | |
| monkeypatch.setenv("CONDA_DEFAULT_ENV", "BLOOM-bringup") | |
| monkeypatch.setattr( | |
| config_extra, | |
| "run_schema_drift_check", | |
| lambda target_label: { | |
| "status": "clean", | |
| "checked_at": "2026-03-29T12:00:00+00:00", | |
| "target": target_label, | |
| "tool_version": "4.1.1", | |
| "summary": "ok", | |
| "report": {"counts": {"expected": 12, "live": 12}}, | |
| "stderr": "", | |
| }, | |
| ) | |
| monkeypatch.setattr(config_extra, "validate_settings", lambda: []) | |
| monkeypatch.setattr(config_extra, "assert_tapdb_version", lambda: "4.1.1") | |
| result = runner.invoke(cli_app, ["config", "doctor"]) | |
| assert result.exit_code == 0 | |
| assert "Conda environment: BLOOM-bringup" in result.output | |
| assert "expected: BLOOM)" not in result.output | |
| def test_config_shell_help(self, runner: CliRunner, cli_app) -> None: | |
| result = runner.invoke(cli_app, ["config", "shell", "--help"]) | |
| assert result.exit_code == 0 | |
| class TestConfigValidation: | |
| def test_config_init_then_validate( | |
| self, runner: CliRunner, cli_app, tmp_path: Path | |
| ) -> None: | |
| result = runner.invoke(cli_app, ["config", "init"]) | |
| assert result.exit_code == 0 | |
| config_path = get_user_config_path() | |
| assert config_path.exists() | |
| result = runner.invoke(cli_app, ["config", "validate"]) | |
| assert result.exit_code == 0 | |
| assert "Config is valid" in result.output | |
| def test_config_validate_rejects_invalid_yaml( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| tmp_path: Path, | |
| ) -> None: | |
| config_path = get_user_config_path() | |
| config_path.parent.mkdir(parents=True, exist_ok=True) | |
| config_path.write_text("auth:\n cognito_user_pool_id: [\n", encoding="utf-8") | |
| result = runner.invoke(cli_app, ["config", "validate"]) | |
| assert result.exit_code != 0 | |
| assert "YAML parse error" in result.output | |
| def test_config_validate_rejects_semantic_errors( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| tmp_path: Path, | |
| ) -> None: | |
| config_path = get_user_config_path() | |
| config_path.parent.mkdir(parents=True, exist_ok=True) | |
| config_path.write_text("environment: invalid\n", encoding="utf-8") | |
| result = runner.invoke(cli_app, ["config", "validate"]) | |
| assert result.exit_code != 0 | |
| assert "environment" in result.output | |
| class TestServerState: | |
| def test_server_status_ignores_legacy_pid_files( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| tmp_path: Path, | |
| ) -> None: | |
| legacy_pid = tmp_path / ".bloom" / "server.pid" | |
| legacy_pid.parent.mkdir(parents=True, exist_ok=True) | |
| legacy_pid.write_text("4321", encoding="utf-8") | |
| result = runner.invoke(cli_app, ["server", "status"]) | |
| assert result.exit_code == 0 | |
| assert "not running" in result.output.lower() | |
| def test_server_logs_ignores_legacy_logs( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| tmp_path: Path, | |
| ) -> None: | |
| legacy_log = tmp_path / ".bloom" / "logs" / "server_20260101_000000.log" | |
| legacy_log.parent.mkdir(parents=True, exist_ok=True) | |
| legacy_log.write_text("legacy log\n", encoding="utf-8") | |
| result = runner.invoke(cli_app, ["server", "logs", "--service", "server"]) | |
| assert result.exit_code == 0 | |
| assert "No log files found" in result.output | |
| def test_info_reports_server_status_from_xdg_state( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| tmp_path: Path, | |
| monkeypatch: pytest.MonkeyPatch, | |
| ) -> None: | |
| monkeypatch.setattr( | |
| server_commands, | |
| "server_status_label", | |
| lambda: "Running (HTTPS, PID 321)", | |
| ) | |
| result = runner.invoke(cli_app, ["info"]) | |
| assert result.exit_code == 0 | |
| assert "Dev Server" in result.output | |
| assert "321" in result.output | |
| class TestServerTlsBehavior: | |
| def _fake_settings(self): | |
| return SimpleNamespace( | |
| host="0.0.0.0", | |
| port=8912, | |
| environment="development", | |
| auth=SimpleNamespace( | |
| cognito_user_pool_id="pool", | |
| cognito_client_id="client", | |
| cognito_domain="bloom.auth.us-east-1.amazoncognito.com", | |
| cognito_redirect_uri="https://localhost:8912/auth/callback", | |
| cognito_logout_redirect_uri="https://localhost:8912/", | |
| ), | |
| atlas=SimpleNamespace(webhook_secret="secret"), | |
| ) | |
| def _patch_startup_dependencies(self, monkeypatch: pytest.MonkeyPatch) -> None: | |
| fake_settings = self._fake_settings() | |
| monkeypatch.setattr(server_commands, "get_settings", lambda: fake_settings) | |
| monkeypatch.setattr( | |
| server_commands, "apply_runtime_environment", lambda settings: settings | |
| ) | |
| monkeypatch.setattr( | |
| server_commands, "atlas_webhook_secret_warning", lambda _settings: None | |
| ) | |
| monkeypatch.setattr( | |
| server_commands, | |
| "get_tapdb_db_config", | |
| lambda: {"host": "localhost", "port": 5432, "database": "bloom"}, | |
| ) | |
| def test_server_start_uses_shared_dayhoff_certs_and_reports_https( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| monkeypatch: pytest.MonkeyPatch, | |
| tmp_path: Path, | |
| ) -> None: | |
| self._patch_startup_dependencies(monkeypatch) | |
| calls: dict[str, object] = {} | |
| cert_pair = ResolvedHttpsCerts( | |
| cert_path=tmp_path / "shared" / "cert.pem", | |
| key_path=tmp_path / "shared" / "key.pem", | |
| source="shared-state", | |
| ) | |
| def fake_resolve_https_certs(**kwargs): | |
| calls["resolve_kwargs"] = kwargs | |
| cert_pair.cert_path.parent.mkdir(parents=True, exist_ok=True) | |
| cert_pair.cert_path.write_text("cert", encoding="utf-8") | |
| cert_pair.key_path.write_text("key", encoding="utf-8") | |
| return cert_pair | |
| def fake_run(cmd, **kwargs): | |
| calls["cmd"] = cmd | |
| calls["cwd"] = kwargs.get("cwd") | |
| calls["env"] = kwargs.get("env") | |
| return SimpleNamespace(returncode=0) | |
| monkeypatch.setattr( | |
| server_commands, "resolve_https_certs", fake_resolve_https_certs | |
| ) | |
| monkeypatch.setattr(server_commands.subprocess, "run", fake_run) | |
| result = runner.invoke(cli_app, ["server", "start", "--foreground"]) | |
| assert result.exit_code == 0, result.output | |
| assert "https://localhost:8912" in result.output | |
| assert ( | |
| calls["resolve_kwargs"]["shared_certs_dir"] | |
| == server_commands._deployment_shared_certs_dir() | |
| ) | |
| assert ( | |
| calls["resolve_kwargs"]["fallback_certs_dir"] | |
| == server_commands.PROJECT_ROOT / "certs" | |
| ) | |
| assert "--ssl-certfile" in calls["cmd"] | |
| assert str(cert_pair.cert_path) in calls["cmd"] | |
| assert "--ssl-keyfile" in calls["cmd"] | |
| assert str(cert_pair.key_path) in calls["cmd"] | |
| assert json.loads( | |
| server_commands._runtime_meta_file().read_text(encoding="utf-8") | |
| ) == {"ssl_enabled": True} | |
| def test_server_uses_shared_cli_core_cert_resolver(self) -> None: | |
| assert server_commands.resolve_https_certs.__module__ == "cli_core_yo.certs" | |
| assert ( | |
| server_commands.shared_dayhoff_certs_dir.__module__ == "cli_core_yo.certs" | |
| ) | |
| def test_server_start_no_ssl_skips_cert_resolution_and_reports_http( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| monkeypatch: pytest.MonkeyPatch, | |
| ) -> None: | |
| self._patch_startup_dependencies(monkeypatch) | |
| resolve_called = False | |
| calls: dict[str, object] = {} | |
| def fake_resolve_https_certs(**_kwargs): | |
| nonlocal resolve_called | |
| resolve_called = True | |
| raise AssertionError( | |
| "resolve_https_certs should not be called for --no-ssl" | |
| ) | |
| def fake_run(cmd, **kwargs): | |
| calls["cmd"] = cmd | |
| return SimpleNamespace(returncode=0) | |
| monkeypatch.setattr( | |
| server_commands, "resolve_https_certs", fake_resolve_https_certs | |
| ) | |
| monkeypatch.setattr(server_commands.subprocess, "run", fake_run) | |
| result = runner.invoke(cli_app, ["server", "start", "--foreground", "--no-ssl"]) | |
| assert result.exit_code == 0, result.output | |
| assert "http://localhost:8912" in result.output | |
| assert resolve_called is False | |
| assert "--ssl-certfile" not in calls["cmd"] | |
| assert "--ssl-keyfile" not in calls["cmd"] | |
| assert json.loads( | |
| server_commands._runtime_meta_file().read_text(encoding="utf-8") | |
| ) == {"ssl_enabled": False} | |
| def test_server_status_uses_runtime_meta_scheme( | |
| self, | |
| runner: CliRunner, | |
| cli_app, | |
| monkeypatch: pytest.MonkeyPatch, | |
| tmp_path: Path, | |
| ) -> None: | |
| pid_file = tmp_path / "server.pid" | |
| pid_file.write_text("321", encoding="utf-8") | |
| meta_file = tmp_path / "server-meta.json" | |
| meta_file.write_text( | |
| json.dumps({"ssl_enabled": False}), | |
| encoding="utf-8", | |
| ) | |
| monkeypatch.setattr( | |
| server_commands, | |
| "active_server_pid", | |
| lambda: (321, pid_file), | |
| ) | |
| monkeypatch.setattr(server_commands, "_runtime_meta_file", lambda: meta_file) | |
| result = runner.invoke(cli_app, ["server", "status"]) | |
| assert result.exit_code == 0 | |
| assert "http://localhost:8912" in result.output | |
| assert "Running (HTTP, PID 321)" in server_commands.server_status_label() | |
| class TestGuiLocalhostPolicy: | |
| def test_ensure_certs_generates_localhost_only_cert( | |
| self, | |
| tmp_path: Path, | |
| monkeypatch: pytest.MonkeyPatch, | |
| ) -> None: | |
| import cli_core_yo.certs as certs_mod | |
| certs_dir = tmp_path / "certs" | |
| certs_dir.mkdir(parents=True, exist_ok=True) | |
| calls: list[list[str]] = [] | |
| def fake_run(args, **kwargs): | |
| calls.append(args) | |
| if "-key-file" in args and "-cert-file" in args: | |
| key_file = args[args.index("-key-file") + 1] | |
| cert_file = args[args.index("-cert-file") + 1] | |
| Path(key_file).write_text("key", encoding="utf-8") | |
| Path(cert_file).write_text("cert", encoding="utf-8") | |
| return type("Result", (), {"returncode": 0})() | |
| monkeypatch.setattr(certs_mod.subprocess, "run", fake_run) | |
| monkeypatch.setattr( | |
| certs_mod.shutil, "which", lambda _: "/usr/local/bin/mkcert" | |
| ) | |
| cert_file, key_file = certs_mod.ensure_certs(certs_dir) | |
| assert cert_file.exists() | |
| assert key_file.exists() | |
| cert_gen_call = next(call for call in calls if "-key-file" in call) | |
| assert "localhost" in cert_gen_call | |
Xet Storage Details
- Size:
- 21.1 kB
- Xet hash:
- 727c727b00cae1383a242fb045b4349842e2cfac223c8ce6b7456185a96ec55f
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.