雷电芽衣
aa4b8a8bdf
Split the three oversized test files into support modules and topic files, evaluate the rmdir dir_fd capability once at import, and drop unused imports. Claude-Session: https://claude.ai/code/session_01Agoc9bRVE9KL7mmWtey9Vq
363 lines
12 KiB
Python
363 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
import os
|
|
from pathlib import Path
|
|
import subprocess # nosec B404
|
|
import sys
|
|
|
|
import pytest
|
|
|
|
from gemini_support import (
|
|
AGENT_ID,
|
|
MISSING,
|
|
VALID_PRIVATE_KEY,
|
|
assert_managed_handler,
|
|
legacy_handler,
|
|
managed_handler,
|
|
prepare_fixture,
|
|
write_json,
|
|
write_text,
|
|
)
|
|
from elydora.plugins.registry import SUPPORTED_AGENTS
|
|
|
|
|
|
GUARD_NAME = "elydora-guard"
|
|
AUDIT_NAME = "elydora-audit"
|
|
|
|
|
|
def assert_managed_pair(settings: dict, fixture: object) -> None:
|
|
guard = managed_handler(settings, "BeforeTool", GUARD_NAME)
|
|
audit = managed_handler(settings, "AfterTool", AUDIT_NAME)
|
|
assert_managed_handler(guard, GUARD_NAME)
|
|
assert_managed_handler(audit, AUDIT_NAME)
|
|
assert str(fixture.guard_path) not in ("", guard["command"])
|
|
assert str(fixture.hook_path) not in ("", audit["command"])
|
|
|
|
|
|
def test_gemini_is_registered_with_the_official_contract() -> None:
|
|
assert SUPPORTED_AGENTS["gemini"] == {
|
|
"name": "Gemini CLI",
|
|
"hook_event": "BeforeTool/AfterTool",
|
|
"config_path": "$GEMINI_CLI_HOME/.gemini/settings.json",
|
|
}
|
|
|
|
|
|
def test_install_preserves_jsonc_and_writes_one_exact_pair(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
tmp_path: Path,
|
|
capsys: pytest.CaptureFixture[str],
|
|
) -> None:
|
|
existing = "\r\n".join([
|
|
"{",
|
|
" // Keep this user preference.",
|
|
' "theme": "GitHub",',
|
|
' "hooks": {',
|
|
' "FutureEvent": [null],',
|
|
' "BeforeTool": [{ "matcher": "read_file", "hooks": '
|
|
'[{ "type": "command", "command": "user-hook" }] }]',
|
|
" }",
|
|
"}",
|
|
"",
|
|
])
|
|
fixture = prepare_fixture(
|
|
monkeypatch, tmp_path, existing_settings=existing
|
|
)
|
|
project_settings = fixture.project_dir / ".gemini" / "settings.json"
|
|
system_settings = tmp_path / "system-settings.json"
|
|
write_text(project_settings, '{ "owner": "project" }\n')
|
|
write_text(system_settings, '{ "owner": "system" }\n')
|
|
monkeypatch.setenv("GEMINI_CLI_SYSTEM_SETTINGS_PATH", str(system_settings))
|
|
|
|
fixture.install()
|
|
output = capsys.readouterr().out
|
|
assert "run /hooks list" in output
|
|
installed = fixture.settings()
|
|
assert "Keep this user preference" in fixture.source()
|
|
assert "\r\n" in fixture.source()
|
|
assert installed["theme"] == "GitHub"
|
|
assert installed["hooks"]["FutureEvent"] == [None]
|
|
assert installed["hooks"]["BeforeTool"][0]["hooks"][0]["command"] == "user-hook"
|
|
assert_managed_pair(installed, fixture)
|
|
first_source = fixture.source()
|
|
|
|
fixture.install()
|
|
|
|
assert fixture.source() == first_source
|
|
assert project_settings.read_text(encoding="utf-8") == '{ "owner": "project" }\n'
|
|
assert system_settings.read_text(encoding="utf-8") == '{ "owner": "system" }\n'
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("override", "kind"),
|
|
[
|
|
(MISSING, "default"),
|
|
("", "empty"),
|
|
("relative gemini", "relative"),
|
|
("~", "literal_tilde"),
|
|
],
|
|
)
|
|
def test_gemini_home_matches_official_path_resolution(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
tmp_path: Path,
|
|
override: object,
|
|
kind: str,
|
|
) -> None:
|
|
fixture = prepare_fixture(
|
|
monkeypatch, tmp_path, gemini_home_override=override
|
|
)
|
|
|
|
fixture.install()
|
|
|
|
expected = {
|
|
"default": fixture.home_dir / ".gemini" / "settings.json",
|
|
"empty": fixture.home_dir / ".gemini" / "settings.json",
|
|
"relative": fixture.project_dir / "relative gemini" / ".gemini" / "settings.json",
|
|
"literal_tilde": fixture.project_dir / "~" / ".gemini" / "settings.json",
|
|
}[kind]
|
|
assert fixture.config_path == expected
|
|
assert expected.is_file()
|
|
|
|
|
|
INVALID_SETTINGS = [
|
|
("{ malformed", "parse Gemini CLI user settings"),
|
|
("[]", "must contain a JSON object"),
|
|
('{ "theme": true, }', "trailing commas are not allowed"),
|
|
('{ "hooks": {}, "hooks": {} }', 'duplicate field "hooks"'),
|
|
('{ "hooks": null }', 'field "hooks" must be an object'),
|
|
('{ "hooks": { "BeforeTool": null } }', "must be an array"),
|
|
('{ "hooks": { "BeforeTool": [null] } }', "group.*must be an object"),
|
|
(
|
|
'{ "hooks": { "BeforeTool": [{ "matcher": 1, "hooks": [] }] } }',
|
|
"matcher must be a string",
|
|
),
|
|
(
|
|
'{ "hooks": { "BeforeTool": [{ "sequential": 1, "hooks": [] }] } }',
|
|
"sequential must be a boolean",
|
|
),
|
|
('{ "hooks": { "BeforeTool": [{}] } }', "hooks array"),
|
|
('{ "hooks": { "BeforeTool": [{ "hooks": [null] }] } }', "handler"),
|
|
(
|
|
'{ "hooks": { "BeforeTool": [{ "hooks": [{ "type": "http" }] }] } }',
|
|
"unsupported type",
|
|
),
|
|
(
|
|
'{ "hooks": { "BeforeTool": [{ "hooks": [{ "type": "command", '
|
|
'"command": "" }] }] } }',
|
|
"non-empty command",
|
|
),
|
|
(
|
|
'{ "hooks": { "BeforeTool": [{ "hooks": [{ "type": "command", '
|
|
'"command": "x", "timeout": -1 }] }] } }',
|
|
"non-negative finite number",
|
|
),
|
|
(
|
|
'{ "hooks": { "BeforeTool": [{ "hooks": [{ "type": "command", '
|
|
'"command": "x", "env": { "A": 1 } }] }] } }',
|
|
"env must map names to strings",
|
|
),
|
|
('{ "hooksConfig": null }', "hooksConfig.*must be an object"),
|
|
('{ "hooksConfig": { "future": true } }', 'unsupported field "future"'),
|
|
('{ "hooksConfig": { "enabled": "yes" } }', "enabled.*must be a boolean"),
|
|
('{ "hooksConfig": { "disabled": [1] } }', "array of strings"),
|
|
('{ "hooksConfig": { "notifications": 1 } }', "notifications.*boolean"),
|
|
]
|
|
|
|
|
|
@pytest.mark.parametrize(("source", "pattern"), INVALID_SETTINGS)
|
|
def test_invalid_official_settings_fail_before_every_write(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
tmp_path: Path,
|
|
source: str,
|
|
pattern: str,
|
|
) -> None:
|
|
fixture = prepare_fixture(
|
|
monkeypatch, tmp_path, existing_settings=source
|
|
)
|
|
|
|
with pytest.raises(ValueError, match=pattern):
|
|
fixture.install()
|
|
|
|
assert fixture.source() == source
|
|
assert not fixture.agent_dir.exists()
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("settings", "pattern"),
|
|
[
|
|
({"hooksConfig": {"enabled": False}}, "hooksConfig.enabled"),
|
|
({"hooksConfig": {"disabled": [GUARD_NAME]}}, GUARD_NAME),
|
|
({"hooksConfig": {"disabled": [AUDIT_NAME]}}, AUDIT_NAME),
|
|
],
|
|
)
|
|
def test_canonical_hook_controls_block_installation(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
tmp_path: Path,
|
|
settings: dict,
|
|
pattern: str,
|
|
) -> None:
|
|
fixture = prepare_fixture(
|
|
monkeypatch, tmp_path, existing_settings=settings
|
|
)
|
|
with pytest.raises(ValueError, match=pattern):
|
|
fixture.install()
|
|
assert not fixture.agent_dir.exists()
|
|
|
|
|
|
def test_disabled_legacy_command_blocks_installation(
|
|
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
|
) -> None:
|
|
fixture = prepare_fixture(monkeypatch, tmp_path)
|
|
write_json(fixture.config_path, {
|
|
"hooksConfig": {
|
|
"disabled": [legacy_handler(fixture.guard_path)["command"]]
|
|
}
|
|
})
|
|
|
|
with pytest.raises(ValueError, match="hooksConfig.disabled"):
|
|
fixture.install()
|
|
|
|
assert not fixture.agent_dir.exists()
|
|
|
|
|
|
def test_exact_legacy_hooks_migrate_and_lookalikes_survive_uninstall(
|
|
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
|
) -> None:
|
|
fixture = prepare_fixture(monkeypatch, tmp_path)
|
|
lookalike = legacy_handler(fixture.guard_path)
|
|
lookalike["command"] += " --inspect"
|
|
write_json(fixture.config_path, {
|
|
"hooks": {
|
|
"BeforeTool": [
|
|
{"hooks": [legacy_handler(fixture.guard_path)]},
|
|
{"hooks": [lookalike]},
|
|
],
|
|
"AfterTool": [{"hooks": [legacy_handler(fixture.hook_path)]}],
|
|
}
|
|
})
|
|
|
|
fixture.install()
|
|
settings = fixture.settings()
|
|
assert_managed_pair(settings, fixture)
|
|
assert any(
|
|
group["hooks"][0].get("command") == lookalike["command"]
|
|
for group in settings["hooks"]["BeforeTool"]
|
|
)
|
|
settings["hooks"]["BeforeTool"][-1]["hooks"].append({
|
|
"type": "command", "command": "user-command"
|
|
})
|
|
write_json(fixture.config_path, settings)
|
|
|
|
fixture.plugin.uninstall(AGENT_ID)
|
|
|
|
remaining = fixture.settings()["hooks"]
|
|
assert remaining["BeforeTool"] == [
|
|
{"hooks": [lookalike]},
|
|
{"hooks": [{"type": "command", "command": "user-command"}]},
|
|
]
|
|
assert "AfterTool" not in remaining
|
|
|
|
|
|
def test_uninstall_preserves_user_settings_and_removes_owned_file(
|
|
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
|
) -> None:
|
|
user = prepare_fixture(
|
|
monkeypatch,
|
|
tmp_path / "user",
|
|
existing_settings={"theme": "GitHub", "hooks": {"Notification": []}},
|
|
)
|
|
user.install()
|
|
user.plugin.uninstall(AGENT_ID)
|
|
assert user.settings() == {
|
|
"theme": "GitHub", "hooks": {"Notification": []}
|
|
}
|
|
|
|
owned = prepare_fixture(monkeypatch, tmp_path / "owned")
|
|
owned.install()
|
|
owned.plugin.uninstall(AGENT_ID)
|
|
assert not owned.config_path.exists()
|
|
|
|
|
|
def test_status_requires_enabled_unique_pair_and_strict_runtime(
|
|
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
|
) -> None:
|
|
fixture = prepare_fixture(monkeypatch, tmp_path)
|
|
fixture.install()
|
|
assert fixture.plugin.status()["installed"] is True
|
|
|
|
settings = fixture.settings()
|
|
settings["hooks"]["AfterTool"].append(settings["hooks"]["AfterTool"][-1])
|
|
write_json(fixture.config_path, settings)
|
|
assert fixture.plugin.status()["installed"] is False
|
|
|
|
fixture.install()
|
|
settings = fixture.settings()
|
|
settings["hooksConfig"] = {"disabled": [AUDIT_NAME]}
|
|
write_json(fixture.config_path, settings)
|
|
assert fixture.plugin.status()["installed"] is False
|
|
|
|
settings["hooksConfig"] = {"disabled": []}
|
|
write_json(fixture.config_path, settings)
|
|
write_text(fixture.private_key_path, "invalid")
|
|
with pytest.raises(ValueError, match="canonical 32-byte"):
|
|
fixture.plugin.status()
|
|
|
|
|
|
def test_cli_install_status_and_uninstall_end_to_end(
|
|
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
|
|
) -> None:
|
|
fixture = prepare_fixture(monkeypatch, tmp_path)
|
|
key_path = tmp_path / "install-private.key"
|
|
token_path = tmp_path / "install-token.txt"
|
|
write_text(key_path, VALID_PRIVATE_KEY + "\n")
|
|
write_text(token_path, "token-1\n")
|
|
environment = {
|
|
**os.environ,
|
|
"HOME": str(fixture.home_dir),
|
|
"USERPROFILE": str(fixture.home_dir),
|
|
"GEMINI_CLI_HOME": str(fixture.home_dir),
|
|
}
|
|
root = Path(__file__).parents[1]
|
|
base = [sys.executable, "-m", "elydora.cli"]
|
|
|
|
install = subprocess.run( # nosec B603
|
|
[
|
|
*base, "install", "--agent", "gemini",
|
|
"--org_id", "org-1", "--agent_id", AGENT_ID,
|
|
"--private_key_file", str(key_path),
|
|
"--token_file", str(token_path),
|
|
"--kid", "key-1", "--base_url", "http://127.0.0.1:9",
|
|
],
|
|
capture_output=True,
|
|
check=False,
|
|
cwd=root,
|
|
env=environment,
|
|
text=True,
|
|
)
|
|
assert install.returncode == 0, install.stderr
|
|
assert "run /hooks list" in install.stdout
|
|
assert_managed_pair(fixture.settings(), fixture)
|
|
|
|
status = subprocess.run( # nosec B603
|
|
[*base, "status"],
|
|
capture_output=True,
|
|
check=False,
|
|
cwd=root,
|
|
env=environment,
|
|
text=True,
|
|
)
|
|
assert status.returncode == 0, status.stderr
|
|
assert "Gemini CLI" in status.stdout
|
|
assert "[installed]" in status.stdout
|
|
|
|
uninstall = subprocess.run( # nosec B603
|
|
[*base, "uninstall", "--agent", "gemini", "--agent_id", AGENT_ID],
|
|
capture_output=True,
|
|
check=False,
|
|
cwd=root,
|
|
env=environment,
|
|
text=True,
|
|
)
|
|
assert uninstall.returncode == 0, uninstall.stderr
|
|
assert not fixture.config_path.exists()
|
|
assert not fixture.agent_dir.exists()
|