487 lines
16 KiB
Python
487 lines
16 KiB
Python
"""Tests for the ``hermes send`` CLI subcommand.
|
||
|
||
Covers the argument parsing / stdin / file / list behavior of
|
||
``hermes_cli.send_cmd``. The underlying ``send_message_tool`` is stubbed so
|
||
no network I/O or gateway is required.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import io
|
||
import json
|
||
import os
|
||
import tempfile
|
||
from pathlib import Path
|
||
from unittest.mock import patch
|
||
|
||
import pytest
|
||
|
||
from hermes_cli import send_cmd
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Helpers
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def _parse(argv):
|
||
"""Build the top-level parser and return the parsed args for ``argv``."""
|
||
import argparse
|
||
|
||
parser = argparse.ArgumentParser(prog="hermes")
|
||
subparsers = parser.add_subparsers(dest="command")
|
||
send_cmd.register_send_subparser(subparsers)
|
||
return parser.parse_args(["send", *argv])
|
||
|
||
|
||
class _FakeTool:
|
||
"""Replacement for ``tools.send_message_tool.send_message_tool``."""
|
||
|
||
def __init__(self, payload):
|
||
self.payload = payload
|
||
self.calls = []
|
||
|
||
def __call__(self, args, **_kw):
|
||
self.calls.append(dict(args))
|
||
return json.dumps(self.payload)
|
||
|
||
|
||
@pytest.fixture
|
||
def fake_tool(monkeypatch):
|
||
"""Install a fake send_message_tool and return the stub for inspection."""
|
||
import sys
|
||
import types
|
||
|
||
fake = _FakeTool({"success": True, "message_id": "m123"})
|
||
|
||
mod = types.ModuleType("tools.send_message_tool")
|
||
mod.send_message_tool = fake
|
||
# Register the stub so ``from tools.send_message_tool import ...`` inside
|
||
# cmd_send resolves to our fake. Also patch the parent ``tools`` package
|
||
# entry so attribute lookup works.
|
||
monkeypatch.setitem(sys.modules, "tools.send_message_tool", mod)
|
||
return fake
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Happy path
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def test_positional_message_success(fake_tool, capsys):
|
||
args = _parse(["--to", "telegram", "hello world"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
assert fake_tool.calls == [
|
||
{"action": "send", "target": "telegram", "message": "hello world"}
|
||
]
|
||
out = capsys.readouterr()
|
||
assert "sent" in out.out or out.out == "" # "sent" is the default success banner
|
||
|
||
|
||
def test_stdin_message(fake_tool, monkeypatch, capsys):
|
||
# Piped stdin (not a tty) should be consumed as the message body.
|
||
monkeypatch.setattr("sys.stdin", io.StringIO("piped body\n"))
|
||
# Force isatty to return False so the CLI reads from stdin.
|
||
monkeypatch.setattr("sys.stdin.isatty", lambda: False)
|
||
args = _parse(["--to", "discord:#ops"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
assert fake_tool.calls[0]["message"] == "piped body\n"
|
||
assert fake_tool.calls[0]["target"] == "discord:#ops"
|
||
|
||
|
||
def test_file_message(fake_tool, tmp_path):
|
||
body = tmp_path / "msg.txt"
|
||
body.write_text("from a file\n")
|
||
args = _parse(["--to", "slack:#eng", "--file", str(body)])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
assert fake_tool.calls[0]["message"] == "from a file\n"
|
||
|
||
|
||
def test_file_dash_means_stdin(fake_tool, monkeypatch):
|
||
monkeypatch.setattr("sys.stdin", io.StringIO("dash body"))
|
||
args = _parse(["--to", "telegram", "--file", "-"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
assert fake_tool.calls[0]["message"] == "dash body"
|
||
|
||
|
||
def test_subject_passed_as_structured_field(fake_tool):
|
||
args = _parse(["--to", "telegram", "--subject", "[CI]", "body text"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
assert fake_tool.calls[0]["message"] == "body text"
|
||
assert fake_tool.calls[0]["subject"] == "[CI]"
|
||
|
||
|
||
def test_json_mode_emits_payload(fake_tool, capsys):
|
||
args = _parse(["--to", "telegram", "--json", "hi"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
out = capsys.readouterr().out
|
||
payload = json.loads(out)
|
||
assert payload.get("success") is True
|
||
assert payload.get("message_id") == "m123"
|
||
|
||
|
||
def test_email_cli_end_to_end_builds_real_subject_link_and_attachment(monkeypatch):
|
||
sent = {}
|
||
|
||
class _FakeSMTP:
|
||
def __init__(self, host, port):
|
||
sent["host"] = host
|
||
sent["port"] = port
|
||
|
||
def starttls(self, context=None):
|
||
sent["starttls"] = True
|
||
|
||
def login(self, address, password):
|
||
sent["login"] = (address, password)
|
||
|
||
def send_message(self, msg):
|
||
sent["msg"] = msg
|
||
|
||
def quit(self):
|
||
sent["quit"] = True
|
||
|
||
with tempfile.TemporaryDirectory() as td, patch.dict(
|
||
os.environ,
|
||
{
|
||
"EMAIL_ADDRESS": "bremen.hermes@gmail.com",
|
||
"EMAIL_PASSWORD": "secret",
|
||
"EMAIL_IMAP_HOST": "imap.test.com",
|
||
"EMAIL_SMTP_HOST": "smtp.test.com",
|
||
"EMAIL_SMTP_PORT": "587",
|
||
},
|
||
clear=False,
|
||
):
|
||
attachment = Path(td) / "result.txt"
|
||
attachment.write_text("attachment-ok\n", encoding="utf-8")
|
||
body = (
|
||
"您好，\n\n"
|
||
"正式版下載：\n"
|
||
"https://example.com/downloads/token\n\n"
|
||
f"MEDIA:{attachment}"
|
||
)
|
||
monkeypatch.setattr("smtplib.SMTP", _FakeSMTP)
|
||
args = _parse([
|
||
"--to", "email:user@example.com",
|
||
"--subject", "大盤測試｜P6 結案報告",
|
||
body,
|
||
])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
|
||
msg = sent["msg"]
|
||
assert msg["Subject"] == "大盤測試｜P6 結案報告"
|
||
assert msg.get_content_type() == "multipart/mixed"
|
||
|
||
attachments = [
|
||
part for part in msg.walk()
|
||
if "attachment" in str(part.get("Content-Disposition", "")).lower()
|
||
]
|
||
assert len(attachments) == 1
|
||
assert attachments[0].get_filename() == "result.txt"
|
||
|
||
plain_parts = [
|
||
part for part in msg.walk()
|
||
if part.get_content_type() == "text/plain"
|
||
and "attachment" not in str(part.get("Content-Disposition", "")).lower()
|
||
]
|
||
html_parts = [
|
||
part for part in msg.walk()
|
||
if part.get_content_type() == "text/html"
|
||
]
|
||
assert len(plain_parts) == 1
|
||
assert len(html_parts) == 1
|
||
|
||
plain = plain_parts[0].get_payload(decode=True).decode("utf-8")
|
||
html = html_parts[0].get_payload(decode=True).decode("utf-8")
|
||
assert "<https://example.com/downloads/token>" in plain
|
||
assert 'href="https://example.com/downloads/token"' in html
|
||
assert "MEDIA:" not in plain
|
||
assert "MEDIA:" not in html
|
||
|
||
|
||
def test_quiet_suppresses_stdout(fake_tool, capsys):
|
||
args = _parse(["--to", "telegram", "--quiet", "shh"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
out = capsys.readouterr()
|
||
assert out.out == ""
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Error paths
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def test_missing_target(fake_tool, capsys, monkeypatch):
|
||
# Ensure stdin is a tty so the CLI does not try to consume it as a body.
|
||
monkeypatch.setattr("sys.stdin.isatty", lambda: True)
|
||
args = _parse(["hello"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 2
|
||
err = capsys.readouterr().err
|
||
assert "--to" in err
|
||
|
||
|
||
def test_missing_message(fake_tool, capsys, monkeypatch):
|
||
monkeypatch.setattr("sys.stdin.isatty", lambda: True)
|
||
args = _parse(["--to", "telegram"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 2
|
||
err = capsys.readouterr().err
|
||
assert "no message" in err.lower()
|
||
|
||
|
||
def test_file_not_found_is_usage_error(fake_tool, capsys, monkeypatch):
|
||
monkeypatch.setattr("sys.stdin.isatty", lambda: True)
|
||
args = _parse(["--to", "telegram", "--file", "/nonexistent/does-not-exist.txt"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 2
|
||
err = capsys.readouterr().err
|
||
assert "cannot read" in err.lower()
|
||
|
||
|
||
def test_file_decode_error_suggests_media_directive(fake_tool, capsys, monkeypatch, tmp_path):
|
||
monkeypatch.setattr("sys.stdin.isatty", lambda: True)
|
||
bad = tmp_path / "bad-bytes.bin"
|
||
bad.write_bytes(b"\xff\xfe\x00")
|
||
|
||
args = _parse(["--to", "telegram", "--file", str(bad)])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 2
|
||
err = capsys.readouterr().err
|
||
assert "not a text file" in err.lower()
|
||
assert f"MEDIA:{bad}" in err
|
||
assert "[[as_document]]" in err
|
||
|
||
|
||
def test_tool_error_returns_failure_exit(monkeypatch, capsys):
|
||
import sys as _sys
|
||
import types as _types
|
||
|
||
fake_mod = _types.ModuleType("tools.send_message_tool")
|
||
|
||
def _bad_tool(args, **_kw):
|
||
return json.dumps({"error": "platform blew up"})
|
||
|
||
fake_mod.send_message_tool = _bad_tool
|
||
monkeypatch.setitem(_sys.modules, "tools.send_message_tool", fake_mod)
|
||
|
||
args = _parse(["--to", "telegram", "nope"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 1
|
||
err = capsys.readouterr().err
|
||
assert "platform blew up" in err
|
||
|
||
|
||
def test_skipped_result_is_success(monkeypatch):
|
||
import sys as _sys
|
||
import types as _types
|
||
|
||
fake_mod = _types.ModuleType("tools.send_message_tool")
|
||
fake_mod.send_message_tool = lambda args, **_kw: json.dumps(
|
||
{"success": True, "skipped": True, "reason": "duplicate"}
|
||
)
|
||
monkeypatch.setitem(_sys.modules, "tools.send_message_tool", fake_mod)
|
||
|
||
args = _parse(["--to", "telegram", "dup"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# --list
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def test_list_human_output(monkeypatch, capsys):
|
||
import sys as _sys
|
||
import types as _types
|
||
|
||
fake_dir = _types.ModuleType("gateway.channel_directory")
|
||
fake_dir.format_directory_for_display = lambda: "Available messaging targets:\n\nTelegram:\n telegram:-100123\n"
|
||
fake_dir.load_directory = lambda: {
|
||
"platforms": {"telegram": [{"id": "-100123", "name": "Test Group"}]}
|
||
}
|
||
monkeypatch.setitem(_sys.modules, "gateway.channel_directory", fake_dir)
|
||
|
||
args = _parse(["--list"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
out = capsys.readouterr().out
|
||
assert "Telegram" in out
|
||
|
||
|
||
def test_list_json(monkeypatch, capsys):
|
||
import sys as _sys
|
||
import types as _types
|
||
|
||
fake_dir = _types.ModuleType("gateway.channel_directory")
|
||
fake_dir.format_directory_for_display = lambda: "(ignored in json mode)"
|
||
fake_dir.load_directory = lambda: {
|
||
"platforms": {"telegram": [{"id": "-100123", "name": "Test Group"}]}
|
||
}
|
||
monkeypatch.setitem(_sys.modules, "gateway.channel_directory", fake_dir)
|
||
|
||
args = _parse(["--list", "--json"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
out = capsys.readouterr().out
|
||
payload = json.loads(out)
|
||
assert payload["platforms"]["telegram"][0]["name"] == "Test Group"
|
||
|
||
|
||
def test_list_filter_platform(monkeypatch, capsys):
|
||
import sys as _sys
|
||
import types as _types
|
||
|
||
fake_dir = _types.ModuleType("gateway.channel_directory")
|
||
fake_dir.format_directory_for_display = lambda: "(should not be called when filter set)"
|
||
fake_dir.load_directory = lambda: {
|
||
"platforms": {
|
||
"telegram": [{"id": "-100123", "name": "TG Chat"}],
|
||
"discord": [{"id": "555", "name": "bot-home"}],
|
||
}
|
||
}
|
||
monkeypatch.setitem(_sys.modules, "gateway.channel_directory", fake_dir)
|
||
|
||
# When --list is set, argparse puts the optional bareword in the
|
||
# `message` positional slot (where the send-mode body would go).
|
||
args = _parse(["--list", "telegram"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 0
|
||
out = capsys.readouterr().out
|
||
assert "telegram" in out.lower()
|
||
assert "discord" not in out.lower()
|
||
|
||
|
||
def test_list_unknown_platform_fails(monkeypatch, capsys):
|
||
import sys as _sys
|
||
import types as _types
|
||
|
||
fake_dir = _types.ModuleType("gateway.channel_directory")
|
||
fake_dir.format_directory_for_display = lambda: ""
|
||
fake_dir.load_directory = lambda: {"platforms": {"telegram": []}}
|
||
monkeypatch.setitem(_sys.modules, "gateway.channel_directory", fake_dir)
|
||
|
||
args = _parse(["--list", "pigeon-post"])
|
||
with pytest.raises(SystemExit) as exc:
|
||
send_cmd.cmd_send(args)
|
||
assert exc.value.code == 1
|
||
err = capsys.readouterr().err
|
||
assert "pigeon-post" in err
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Parser registration contract
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def test_register_send_subparser_is_reusable():
|
||
"""Sanity check: the registrar returns a parser and wires ``cmd_send``."""
|
||
import argparse
|
||
|
||
parser = argparse.ArgumentParser()
|
||
subparsers = parser.add_subparsers(dest="command")
|
||
send_parser = send_cmd.register_send_subparser(subparsers)
|
||
assert send_parser is not None
|
||
args = parser.parse_args(["send", "--to", "telegram", "hi"])
|
||
assert args.func is send_cmd.cmd_send
|
||
assert args.to == "telegram"
|
||
assert args.message == "hi"
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Env loader
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def test_load_hermes_env_bridges_config_yaml_scalars(tmp_path, monkeypatch):
|
||
"""Top-level config.yaml scalars should be bridged into os.environ.
|
||
|
||
This mirrors the gateway/run.py bootstrap behavior: without this, running
|
||
``hermes send`` from a fresh shell cannot resolve the home channel
|
||
because ``TELEGRAM_HOME_CHANNEL`` (saved by ``hermes config set``) lives
|
||
in config.yaml, not in .env — and the gateway's config loader reads via
|
||
``os.getenv(...)``.
|
||
"""
|
||
import os
|
||
|
||
hermes_home = tmp_path / ".hermes"
|
||
hermes_home.mkdir()
|
||
(hermes_home / ".env").write_text("SOME_TOKEN=abc123\n")
|
||
(hermes_home / "config.yaml").write_text(
|
||
"TELEGRAM_HOME_CHANNEL: '5550001111'\nnested:\n ignored: true\n"
|
||
)
|
||
|
||
monkeypatch.setenv("HERMES_HOME", str(hermes_home))
|
||
monkeypatch.delenv("TELEGRAM_HOME_CHANNEL", raising=False)
|
||
monkeypatch.delenv("SOME_TOKEN", raising=False)
|
||
|
||
# Force get_hermes_home() to re-resolve under the patched env.
|
||
from importlib import reload
|
||
|
||
import hermes_cli.config as _hc_config
|
||
reload(_hc_config)
|
||
|
||
send_cmd._load_hermes_env()
|
||
|
||
assert os.environ.get("SOME_TOKEN") == "abc123"
|
||
assert os.environ.get("TELEGRAM_HOME_CHANNEL") == "5550001111"
|
||
|
||
|
||
def test_load_hermes_env_does_not_override_existing(tmp_path, monkeypatch):
|
||
"""Existing env vars must not be clobbered by config.yaml values."""
|
||
import os
|
||
|
||
hermes_home = tmp_path / ".hermes"
|
||
hermes_home.mkdir()
|
||
(hermes_home / "config.yaml").write_text("TELEGRAM_HOME_CHANNEL: yaml_value\n")
|
||
|
||
monkeypatch.setenv("HERMES_HOME", str(hermes_home))
|
||
monkeypatch.setenv("TELEGRAM_HOME_CHANNEL", "env_value")
|
||
|
||
from importlib import reload
|
||
import hermes_cli.config as _hc_config
|
||
reload(_hc_config)
|
||
|
||
send_cmd._load_hermes_env()
|
||
|
||
assert os.environ.get("TELEGRAM_HOME_CHANNEL") == "env_value"
|
||
|
||
|
||
def test_load_hermes_env_handles_missing_files(tmp_path, monkeypatch):
|
||
"""No .env or config.yaml should be a silent no-op, not an exception."""
|
||
hermes_home = tmp_path / ".hermes"
|
||
hermes_home.mkdir()
|
||
monkeypatch.setenv("HERMES_HOME", str(hermes_home))
|
||
|
||
from importlib import reload
|
||
import hermes_cli.config as _hc_config
|
||
reload(_hc_config)
|
||
|
||
# Should not raise.
|
||
send_cmd._load_hermes_env()
|