@smilintux/skcapstone 0.1.0 → 0.2.3

package/tests/test_cli_test_cmd.py

@@ -0,0 +1,206 @@
+"""Tests for the skcapstone test CLI command (test_cmd.py).
+
+Covers:
+  - Help output is rendered correctly
+  - Invalid package names are rejected with a clear error
+  - JSON output mode produces valid structured JSON
+  - Per-package table renders for available/unavailable packages
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+from skcapstone.cli import main
+from skcapstone.testrunner import PackageResult, TestReport
+
+
+@pytest.fixture()
+def runner():
+    return CliRunner(mix_stderr=False)
+
+
+@pytest.fixture()
+def mock_report_all_pass():
+    """A TestReport where every package passes."""
+    return TestReport(
+        results=[
+            PackageResult(name="skcapstone", passed=10, exit_code=0, duration_s=1.2),
+            PackageResult(name="skcomm", passed=5, exit_code=0, duration_s=0.8),
+        ],
+        duration_s=2.0,
+    )
+
+
+@pytest.fixture()
+def mock_report_with_failure():
+    """A TestReport with one failing package."""
+    return TestReport(
+        results=[
+            PackageResult(name="skcapstone", passed=10, exit_code=0, duration_s=1.2),
+            PackageResult(
+                name="skcomm",
+                passed=3,
+                failed=2,
+                exit_code=1,
+                duration_s=0.9,
+                output="FAILED tests/test_foo.py::test_bar",
+            ),
+        ],
+        duration_s=2.1,
+    )
+
+
+@pytest.fixture()
+def mock_report_unavailable():
+    """A TestReport with one unavailable package."""
+    return TestReport(
+        results=[
+            PackageResult(
+                name="capauth",
+                available=False,
+                output="Test directory not found",
+            ),
+        ],
+        duration_s=0.0,
+    )
+
+
+# ── Help output ──────────────────────────────────────────────────
+
+
+class TestTestCmdHelp:
+    """Ensure help text is registered and contains key information."""
+
+    def test_help_renders(self, runner):
+        """--help exits 0 and shows package names."""
+        result = runner.invoke(main, ["test", "--help"])
+        assert result.exit_code == 0
+        assert "skcapstone" in result.output
+        assert "--package" in result.output
+
+    def test_help_lists_options(self, runner):
+        """--help shows all major options."""
+        result = runner.invoke(main, ["test", "--help"])
+        assert "--fast" in result.output
+        assert "--verbose" in result.output
+        assert "--json-out" in result.output
+        assert "--timeout" in result.output
+
+
+# ── Invalid package validation ───────────────────────────────────
+
+
+class TestInvalidPackage:
+    """Unknown package names should be rejected immediately."""
+
+    def test_invalid_package_exits_nonzero(self, runner):
+        """Passing an unknown --package name exits with code 1."""
+        result = runner.invoke(main, ["test", "--package", "does-not-exist"])
+        assert result.exit_code == 1
+
+    def test_invalid_package_shows_valid_names(self, runner):
+        """Error message lists the valid package names."""
+        result = runner.invoke(main, ["test", "--package", "bogus"])
+        assert "bogus" in result.output
+        assert "skcapstone" in result.output
+
+    def test_valid_package_accepted(self, runner, mock_report_all_pass):
+        """A valid package name is accepted and run_all_tests is called."""
+        with patch(
+            "skcapstone.cli.test_cmd.run_all_tests",
+            return_value=mock_report_all_pass,
+        ):
+            result = runner.invoke(main, ["test", "--package", "skcomm"])
+        assert result.exit_code == 0
+
+
+# ── JSON output mode ─────────────────────────────────────────────
+
+
+class TestJsonOutput:
+    """--json-out should produce parseable JSON with the right structure."""
+
+    def test_json_out_is_parseable(self, runner, mock_report_all_pass):
+        """JSON output can be loaded by json.loads."""
+        with patch(
+            "skcapstone.cli.test_cmd.run_all_tests",
+            return_value=mock_report_all_pass,
+        ):
+            result = runner.invoke(main, ["test", "--json-out"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "all_passed" in data
+        assert "packages" in data
+
+    def test_json_exit_nonzero_on_failure(self, runner, mock_report_with_failure):
+        """JSON mode still exits 1 when tests fail."""
+        with patch(
+            "skcapstone.cli.test_cmd.run_all_tests",
+            return_value=mock_report_with_failure,
+        ):
+            result = runner.invoke(main, ["test", "--json-out"])
+        assert result.exit_code == 1
+        data = json.loads(result.output)
+        assert data["all_passed"] is False
+
+    def test_json_has_package_details(self, runner, mock_report_all_pass):
+        """Each package result appears in the packages array."""
+        with patch(
+            "skcapstone.cli.test_cmd.run_all_tests",
+            return_value=mock_report_all_pass,
+        ):
+            result = runner.invoke(main, ["test", "--json-out"])
+        data = json.loads(result.output)
+        pkg_names = [p["name"] for p in data["packages"]]
+        assert "skcapstone" in pkg_names
+
+
+# ── Table rendering ──────────────────────────────────────────────
+
+
+class TestTableRendering:
+    """Rich table should contain pass/fail/skip columns."""
+
+    def test_pass_table_shows_pass(self, runner, mock_report_all_pass):
+        """PASS appears in the output when all tests succeed."""
+        with patch(
+            "skcapstone.cli.test_cmd.run_all_tests",
+            return_value=mock_report_all_pass,
+        ):
+            result = runner.invoke(main, ["test"])
+        assert result.exit_code == 0
+        assert "PASS" in result.output
+
+    def test_fail_table_shows_fail(self, runner, mock_report_with_failure):
+        """FAIL appears in the output when a package fails."""
+        with patch(
+            "skcapstone.cli.test_cmd.run_all_tests",
+            return_value=mock_report_with_failure,
+        ):
+            result = runner.invoke(main, ["test"])
+        assert result.exit_code == 1
+        assert "FAIL" in result.output
+
+    def test_unavailable_package_shows_na(self, runner, mock_report_unavailable):
+        """Packages without test dirs show N/A, not an error."""
+        with patch(
+            "skcapstone.cli.test_cmd.run_all_tests",
+            return_value=mock_report_unavailable,
+        ):
+            result = runner.invoke(main, ["test"])
+        assert "N/A" in result.output
+
+    def test_show_output_flag_prints_failures(self, runner, mock_report_with_failure):
+        """--show-output flag prints pytest output for failing packages."""
+        with patch(
+            "skcapstone.cli.test_cmd.run_all_tests",
+            return_value=mock_report_with_failure,
+        ):
+            result = runner.invoke(main, ["test", "--show-output"])
+        assert "test_bar" in result.output

package/tests/test_cli_test_connection.py

@@ -0,0 +1,364 @@
+"""Tests for skcapstone test-connection command.
+
+Covers:
+- Happy path: peer responds with pong, latency reported
+- Timeout: peer never replies, command exits with code 1
+- No-transport: SKComm has no live transport, error reported
+- Payload helpers: _make_ping_payload / _is_pong_for / _is_ping / _make_pong_payload
+- --count > 1: multi-ping summary statistics
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from skcapstone.cli.test_connection import (
+    _is_ping,
+    _is_pong_for,
+    _make_ping_payload,
+    _make_pong_payload,
+    ping_peer,
+)
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def agent_home(tmp_path):
+    """Minimal agent home directory for CLI tests."""
+    home = tmp_path / ".skcapstone"
+    (home / "identity").mkdir(parents=True)
+    (home / "config").mkdir(parents=True)
+    identity = {
+        "name": "TestAgent",
+        "fingerprint": "AABB1234",
+        "capauth_managed": False,
+    }
+    (home / "identity" / "identity.json").write_text(json.dumps(identity))
+    (home / "manifest.json").write_text(
+        json.dumps({"name": "TestAgent", "version": "0.1.0"})
+    )
+    import yaml
+
+    (home / "config" / "config.yaml").write_text(
+        yaml.dump({"agent_name": "TestAgent"})
+    )
+    return home
+
+
+def _make_mock_chat(delivered: bool, pong_nonce: str | None = None, peer: str = "lumina"):
+    """Build a mocked AgentChat instance.
+
+    Args:
+        delivered: Whether AgentChat.send() reports successful delivery.
+        pong_nonce: When set, AgentChat.receive() will return a pong message
+            matching this nonce on the first call.
+        peer: Peer name used as sender in the pong message.
+
+    Returns:
+        MagicMock configured as AgentChat.
+    """
+    mock_chat = MagicMock()
+    mock_chat.send.return_value = {
+        "stored": True,
+        "delivered": delivered,
+        "transport": "tailscale" if delivered else None,
+        "error": None,
+    }
+
+    if pong_nonce is not None:
+        pong_payload = _make_pong_payload(pong_nonce, peer)
+        mock_chat.receive.return_value = [
+            {"sender": peer, "content": pong_payload}
+        ]
+    else:
+        mock_chat.receive.return_value = []
+
+    return mock_chat
+
+
+# ---------------------------------------------------------------------------
+# Unit tests — payload helpers
+# ---------------------------------------------------------------------------
+
+
+class TestPayloadHelpers:
+    """Verify ping/pong serialization round-trips."""
+
+    def test_make_ping_payload_is_json(self):
+        """Ping payload is valid JSON with required keys."""
+        payload = _make_ping_payload("abc123", "opus")
+        data = json.loads(payload)
+        assert data["skchat_ping"] is True
+        assert data["nonce"] == "abc123"
+        assert data["sender"] == "opus"
+
+    def test_is_pong_for_matching_nonce(self):
+        """_is_pong_for returns True for a matching pong."""
+        pong = _make_pong_payload("xyz-789", "lumina")
+        assert _is_pong_for(pong, "xyz-789") is True
+
+    def test_is_pong_for_wrong_nonce(self):
+        """_is_pong_for returns False when nonce differs."""
+        pong = _make_pong_payload("xyz-789", "lumina")
+        assert _is_pong_for(pong, "different-nonce") is False
+
+    def test_is_pong_for_plain_text(self):
+        """_is_pong_for is False for arbitrary text."""
+        assert _is_pong_for("hello world", "nonce") is False
+
+    def test_is_ping_detects_ping(self):
+        """_is_ping correctly identifies a ping payload."""
+        ping = _make_ping_payload("nonce-42", "opus")
+        ok, nonce, sender = _is_ping(ping)
+        assert ok is True
+        assert nonce == "nonce-42"
+        assert sender == "opus"
+
+    def test_is_ping_plain_text(self):
+        """_is_ping returns False for non-ping content."""
+        ok, nonce, sender = _is_ping("just a regular message")
+        assert ok is False
+        assert nonce == ""
+
+    def test_make_pong_payload_round_trip(self):
+        """Pong payload can be verified by _is_pong_for."""
+        pong = _make_pong_payload("round-trip-nonce", "jarvis")
+        assert _is_pong_for(pong, "round-trip-nonce") is True
+
+
+# ---------------------------------------------------------------------------
+# Unit tests — ping_peer()
+# ---------------------------------------------------------------------------
+
+
+class TestPingPeer:
+    """Tests for the ping_peer() core function."""
+
+    def test_happy_path_reachable(self, agent_home):
+        """ping_peer returns reachable=True when pong arrives."""
+        nonce_holder: list[str] = []
+
+        def fake_send(peer, message, **kwargs):
+            # Capture the nonce from the ping payload
+            data = json.loads(message)
+            nonce_holder.append(data["nonce"])
+            return {"stored": True, "delivered": True, "transport": "tailscale", "error": None}
+
+        def fake_receive(limit=20):
+            if not nonce_holder:
+                return []
+            return [
+                {
+                    "sender": "lumina",
+                    "content": _make_pong_payload(nonce_holder[0], "lumina"),
+                }
+            ]
+
+        mock_chat = MagicMock()
+        mock_chat.send.side_effect = fake_send
+        mock_chat.receive.side_effect = fake_receive
+
+        with patch(
+            "skcapstone.cli.test_connection.AgentChat", return_value=mock_chat
+        ):
+            result = ping_peer("lumina", agent_home, "TestAgent", timeout=2.0)
+
+        assert result["reachable"] is True
+        assert result["latency_ms"] is not None
+        assert result["latency_ms"] >= 0.0
+
+    def test_timeout_unreachable(self, agent_home):
+        """ping_peer returns reachable=False when pong never arrives."""
+        mock_chat = _make_mock_chat(delivered=True, pong_nonce=None)
+
+        with patch(
+            "skcapstone.cli.test_connection.AgentChat", return_value=mock_chat
+        ):
+            # Use a very short timeout so the test runs quickly
+            result = ping_peer("lumina", agent_home, "TestAgent", timeout=0.3)
+
+        assert result["reachable"] is False
+        assert result["latency_ms"] is None
+        assert "timeout" in (result["error"] or "").lower()
+
+    def test_no_live_transport_returns_error(self, agent_home):
+        """ping_peer reports error when send has no live transport."""
+        mock_chat = MagicMock()
+        mock_chat.send.return_value = {
+            "stored": True,
+            "delivered": False,
+            "transport": None,
+            "error": None,
+        }
+
+        with patch(
+            "skcapstone.cli.test_connection.AgentChat", return_value=mock_chat
+        ):
+            result = ping_peer("lumina", agent_home, "TestAgent", timeout=2.0)
+
+        assert result["reachable"] is False
+        assert "transport" in (result["error"] or "").lower()
+
+    def test_send_failure_returns_error(self, agent_home):
+        """ping_peer returns error when send itself fails entirely."""
+        mock_chat = MagicMock()
+        mock_chat.send.return_value = {
+            "stored": False,
+            "delivered": False,
+            "transport": None,
+            "error": "connection refused",
+        }
+
+        with patch(
+            "skcapstone.cli.test_connection.AgentChat", return_value=mock_chat
+        ):
+            result = ping_peer("lumina", agent_home, "TestAgent", timeout=2.0)
+
+        assert result["reachable"] is False
+        assert result["error"] is not None
+
+
+# ---------------------------------------------------------------------------
+# CLI integration tests — skcapstone test-connection
+# ---------------------------------------------------------------------------
+
+
+class TestTestConnectionCLI:
+    """CLI-level tests via CliRunner."""
+
+    def _run(self, args: list[str]):
+        from skcapstone.cli import main
+
+        runner = CliRunner()
+        return runner.invoke(main, args, catch_exceptions=False)
+
+    def test_cli_reachable_exit_zero(self, agent_home):
+        """CLI exits 0 and prints REACHABLE when pong arrives."""
+        nonce_holder: list[str] = []
+
+        def fake_send(peer, message, **kwargs):
+            try:
+                data = json.loads(message)
+                nonce_holder.append(data.get("nonce", ""))
+            except Exception:
+                pass
+            return {
+                "stored": True,
+                "delivered": True,
+                "transport": "tailscale",
+                "error": None,
+            }
+
+        def fake_receive(limit=20):
+            if not nonce_holder:
+                return []
+            return [
+                {
+                    "sender": "lumina",
+                    "content": _make_pong_payload(nonce_holder[0], "lumina"),
+                }
+            ]
+
+        mock_chat = MagicMock()
+        mock_chat.send.side_effect = fake_send
+        mock_chat.receive.side_effect = fake_receive
+
+        with patch("skcapstone.cli.test_connection.AgentChat", return_value=mock_chat):
+            result = self._run(
+                ["test-connection", "lumina", "--home", str(agent_home)]
+            )
+
+        assert result.exit_code == 0, result.output
+        assert "REACHABLE" in result.output
+
+    def test_cli_timeout_exit_one(self, agent_home):
+        """CLI exits 1 and prints UNREACHABLE on timeout."""
+        mock_chat = _make_mock_chat(delivered=True, pong_nonce=None)
+
+        with patch("skcapstone.cli.test_connection.AgentChat", return_value=mock_chat):
+            # Very short timeout so the test completes fast
+            result = self._run(
+                [
+                    "test-connection", "lumina",
+                    "--home", str(agent_home),
+                    "--timeout", "0.3",
+                ]
+            )
+
+        assert result.exit_code == 1, result.output
+        assert "UNREACHABLE" in result.output
+
+    def test_cli_no_transport_exit_one(self, agent_home):
+        """CLI exits 1 when no live transport is available."""
+        mock_chat = MagicMock()
+        mock_chat.send.return_value = {
+            "stored": True,
+            "delivered": False,
+            "transport": None,
+            "error": None,
+        }
+
+        with patch("skcapstone.cli.test_connection.AgentChat", return_value=mock_chat):
+            result = self._run(
+                ["test-connection", "lumina", "--home", str(agent_home)]
+            )
+
+        assert result.exit_code == 1, result.output
+        assert "UNREACHABLE" in result.output
+
+    def test_cli_count_shows_statistics(self, agent_home):
+        """--count 3 produces min/avg/max latency summary."""
+        nonce_holder: list[str] = []
+
+        def fake_send(peer, message, **kwargs):
+            try:
+                data = json.loads(message)
+                nonce_holder.append(data.get("nonce", ""))
+            except Exception:
+                pass
+            return {
+                "stored": True,
+                "delivered": True,
+                "transport": "tailscale",
+                "error": None,
+            }
+
+        def fake_receive(limit=20):
+            if not nonce_holder:
+                return []
+            latest = nonce_holder[-1]
+            return [
+                {
+                    "sender": "lumina",
+                    "content": _make_pong_payload(latest, "lumina"),
+                }
+            ]
+
+        mock_chat = MagicMock()
+        mock_chat.send.side_effect = fake_send
+        mock_chat.receive.side_effect = fake_receive
+
+        with patch("skcapstone.cli.test_connection.AgentChat", return_value=mock_chat):
+            result = self._run(
+                [
+                    "test-connection", "lumina",
+                    "--home", str(agent_home),
+                    "--count", "3",
+                ]
+            )
+
+        assert result.exit_code == 0, result.output
+        # Summary line for multiple pings contains avg=
+        assert "avg=" in result.output
+        assert "min=" in result.output
+        assert "max=" in result.output