MertCapkin-GraphStack 4.5.1__py3-none-any.whl

graphstack/tests/test_platform_utils.py

@@ -0,0 +1,69 @@
+"""Tests for the OS helpers in ``platform_utils``."""
+
+from __future__ import annotations
+
+import sys
+
+import pytest
+
+from graphstack import platform_utils
+
+
+def test_find_python_returns_non_empty_list() -> None:
+    result = platform_utils.find_python()
+    assert isinstance(result, list)
+    assert len(result) >= 1
+    assert all(isinstance(s, str) and s for s in result)
+
+
+def test_find_python_falls_back_to_sys_executable(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(platform_utils.shutil, "which", lambda _name: None)
+    monkeypatch.setattr(platform_utils, "IS_WINDOWS", False)
+    assert platform_utils.find_python() == [sys.executable]
+
+
+def test_find_python_prefers_python3_when_available(monkeypatch: pytest.MonkeyPatch) -> None:
+    available = {"python3": "/usr/bin/python3"}
+    monkeypatch.setattr(
+        platform_utils.shutil,
+        "which",
+        lambda name: available.get(name),
+    )
+    assert platform_utils.find_python() == ["python3"]
+
+
+def test_utc_now_iso_is_well_formed() -> None:
+    stamp = platform_utils.utc_now_iso()
+    # Looks like 2026-05-16T17:00:00+00:00 (or ...Z on some Pythons).
+    assert "T" in stamp
+    assert stamp.endswith("+00:00") or stamp.endswith("Z")
+
+
+def test_emoji_safe_passthrough_on_utf(monkeypatch: pytest.MonkeyPatch) -> None:
+    class _Stream:
+        encoding = "utf-8"
+
+    monkeypatch.setattr(platform_utils.sys, "stdout", _Stream())
+    text = "✅ done — 📋"
+    assert platform_utils.emoji_safe(text) == text
+
+
+def test_emoji_safe_downgrades_on_legacy_encoding(monkeypatch: pytest.MonkeyPatch) -> None:
+    class _Stream:
+        encoding = "cp1254"
+
+    monkeypatch.setattr(platform_utils.sys, "stdout", _Stream())
+    out = platform_utils.emoji_safe("✅ ✗ ⚠️")
+    assert "[ok]" in out
+    assert "[x]" in out
+    assert "[!]" in out
+    assert "✅" not in out
+
+
+def test_echo_never_raises_on_unprintable(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    platform_utils.echo("plain ASCII line")
+    platform_utils.echo("Türkçe ışık ✅")
+    captured = capsys.readouterr()
+    assert "plain ASCII line" in captured.out

graphstack/tests/test_state.py

@@ -0,0 +1,56 @@
+"""Tests for the machine-readable session state (handoff/STATE.json)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from graphstack import state
+
+
+def test_set_then_get_round_trips(project_root: Path,
+                                  capsys: pytest.CaptureFixture[str]) -> None:
+    assert state.run(["set", "--role", "builder", "--task", "t1",
+                      "--note", "cycle 1"]) == 0
+    path = project_root / "handoff" / "STATE.json"
+    assert path.is_file()
+    data = json.loads(path.read_text(encoding="utf-8"))
+    assert data["role"] == "builder"
+    assert data["task_id"] == "t1"
+    assert data["note"] == "cycle 1"
+    assert data["updated_at"]
+
+    capsys.readouterr()
+    assert state.run(["get", "--json"]) == 0
+    out = capsys.readouterr().out
+    assert json.loads(out)["role"] == "builder"
+
+
+def test_get_without_state_returns_error(project_root: Path,
+                                         capsys: pytest.CaptureFixture[str]) -> None:
+    assert state.run(["get"]) == 1
+    assert "no STATE.json" in capsys.readouterr().out
+
+
+def test_clear_is_idempotent(project_root: Path) -> None:
+    state.run(["set", "--role", "qa"])
+    assert state.run(["clear"]) == 0
+    assert not (project_root / "handoff" / "STATE.json").exists()
+    assert state.run(["clear"]) == 0
+
+
+def test_unknown_role_still_writes_with_warning(
+    project_root: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    assert state.run(["set", "--role", "wizard"]) == 0
+    out = capsys.readouterr().out
+    assert "Unknown role" in out
+    assert (project_root / "handoff" / "STATE.json").is_file()
+
+
+def test_load_state_handles_corrupt_json(project_root: Path) -> None:
+    path = project_root / "handoff" / "STATE.json"
+    path.write_text("{not json", encoding="utf-8")
+    assert state.load_state() is None

graphstack/tests/test_validate.py

@@ -0,0 +1,204 @@
+"""Tests for graphstack validate / doctor."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from graphstack.validate import run_checks
+
+
+def _minimal_layout(root: Path) -> None:
+    paths = (
+        ".cursor/rules/graphstack.mdc",
+        "orchestrator/ORCHESTRATOR.md",
+        "orchestrator/TOKEN_OPTIMIZER.md",
+        ".cursor/skills/architect/ARCHITECT.md",
+        ".cursor/skills/builder/BUILDER.md",
+        "handoff/BRIEF.md",
+        "handoff/STATE.md",
+        "handoff/board/README.md",
+        "handoff/board/todo",
+        "handoff/board/doing",
+        "handoff/board/done",
+    )
+    for rel in paths:
+        p = root / rel
+        if rel.endswith(("todo", "doing", "done")):
+            p.mkdir(parents=True, exist_ok=True)
+        else:
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text("# stub\n", encoding="utf-8")
+
+
+def test_validate_reports_template_brief_as_warning(
+    project_root: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    _minimal_layout(project_root)
+    (project_root / "handoff" / "BRIEF.md").write_text(
+        "# Brief: [Feature/Change Name]\n**Status:** Draft\n",
+        encoding="utf-8",
+    )
+    report = run_checks()
+    assert any(f.code == "brief_template" and f.level == "warn" for f in report.findings)
+
+
+def test_validate_strict_template_brief_is_error(
+    project_root: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    _minimal_layout(project_root)
+    (project_root / "handoff" / "BRIEF.md").write_text(
+        "# Brief: [Feature/Change Name]\n",
+        encoding="utf-8",
+    )
+    report = run_checks(strict=True)
+    assert any(f.code == "brief_template" and f.level == "error" for f in report.findings)
+
+
+def test_validate_invalid_board_json_is_error(
+    project_root: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    _minimal_layout(project_root)
+    bad = project_root / "handoff" / "board" / "todo" / "bad.json"
+    bad.write_text("{not json", encoding="utf-8")
+    report = run_checks()
+    assert any(f.code == "task_invalid_json" for f in report.errors)
+
+
+def test_validate_task_missing_keys(
+    project_root: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    _minimal_layout(project_root)
+    task = project_root / "handoff" / "board" / "doing" / "t1.json"
+    task.write_text(json.dumps({"id": "t1"}), encoding="utf-8")
+    report = run_checks()
+    assert any(f.code == "task_missing_keys" for f in report.errors)
+
+
+def test_graph_stale_when_commit_mismatch(
+    project_root: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    import subprocess
+
+    from graphstack import validate as validate_mod
+
+    _minimal_layout(project_root)
+    graph_dir = project_root / "graphify-out"
+    graph_dir.mkdir()
+    (graph_dir / "GRAPH_REPORT.md").write_text(
+        "Built from commit: `deadbeef00000000000000000000000000000000`\n",
+        encoding="utf-8",
+    )
+
+    def fake_git(*args: str, capture: bool = True) -> subprocess.CompletedProcess[str]:
+        if args == ("rev-parse", "HEAD"):
+            return subprocess.CompletedProcess(
+                args, 0, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n", ""
+            )
+        return subprocess.CompletedProcess(args, 1, "", "")
+
+    monkeypatch.setattr(validate_mod, "run_git", fake_git)
+    monkeypatch.setattr(validate_mod, "git_available", lambda: True)
+    report = run_checks(fail_stale=True)
+    assert any(f.code == "graph_stale" for f in report.errors)
+
+
+def test_graph_fresh_when_built_commit_is_ancestor_of_head(
+    project_root: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    import subprocess
+
+    from graphstack import validate as validate_mod
+
+    _minimal_layout(project_root)
+    graph_dir = project_root / "graphify-out"
+    graph_dir.mkdir()
+    old = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    head = "cccccccccccccccccccccccccccccccccccccccc"
+    (graph_dir / "GRAPH_REPORT.md").write_text(
+        f"Built from commit: `{old}`\n",
+        encoding="utf-8",
+    )
+
+    def fake_git(*args: str, capture: bool = True) -> subprocess.CompletedProcess[str]:
+        if args == ("rev-parse", "HEAD"):
+            return subprocess.CompletedProcess(args, 0, f"{head}\n", "")
+        if args == ("rev-parse", "HEAD~1"):
+            return subprocess.CompletedProcess(args, 1, "", "unknown")
+        if args[:2] == ("merge-base", "--is-ancestor"):
+            return subprocess.CompletedProcess(args, 0, "", "")
+        if args[:2] == ("rev-list", "--max-count"):
+            return subprocess.CompletedProcess(args, 0, f"{head}\n", "")
+        if args[:3] == ("log", "-1", "--format=%H"):
+            return subprocess.CompletedProcess(args, 0, f"{head}\n", "")
+        return subprocess.CompletedProcess(args, 1, "", "")
+
+    monkeypatch.setattr(validate_mod, "run_git", fake_git)
+    monkeypatch.setattr(validate_mod, "git_available", lambda: True)
+    report = run_checks(fail_stale=True)
+    assert any(f.code == "graph_fresh" for f in report.findings)
+    assert not report.errors
+
+
+def test_graph_fresh_when_built_from_parent_commit(
+    project_root: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    import subprocess
+
+    from graphstack import validate as validate_mod
+
+    _minimal_layout(project_root)
+    graph_dir = project_root / "graphify-out"
+    graph_dir.mkdir()
+    parent = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+    (graph_dir / "GRAPH_REPORT.md").write_text(
+        f"Built from commit: `{parent}`\n",
+        encoding="utf-8",
+    )
+
+    def fake_git(*args: str, capture: bool = True) -> subprocess.CompletedProcess[str]:
+        if args == ("rev-parse", "HEAD"):
+            return subprocess.CompletedProcess(
+                args, 0, "cccccccccccccccccccccccccccccccccccccccc\n", ""
+            )
+        if args == ("rev-parse", "HEAD~1"):
+            return subprocess.CompletedProcess(args, 0, f"{parent}\n", "")
+        return subprocess.CompletedProcess(args, 1, "", "")
+
+    monkeypatch.setattr(validate_mod, "run_git", fake_git)
+    monkeypatch.setattr(validate_mod, "git_available", lambda: True)
+    report = run_checks(fail_stale=True)
+    assert any(f.code == "graph_fresh" for f in report.findings)
+    assert not report.errors
+
+
+def test_validate_framework_warns_on_dirty_handoff(project_root: Path) -> None:
+    _minimal_layout(project_root)
+    (project_root / ".graphstack-framework").write_text("framework\n", encoding="utf-8")
+    (project_root / "handoff" / "BRIEF.md").write_text(
+        "# Brief: Real Feature\n**Status:** Ready for Builder\n",
+        encoding="utf-8",
+    )
+    done = project_root / "handoff" / "board" / "done"
+    (done / "stale-task.json").write_text(
+        json.dumps({"id": "stale-task", "title": "x", "status": "done",
+                    "created_at": "2026-01-01T00:00:00+00:00"}),
+        encoding="utf-8",
+    )
+    report = run_checks()
+    codes = {f.code for f in report.findings if f.level == "warn"}
+    assert "framework_brief_dirty" in codes
+    assert "framework_board_dirty" in codes
+
+
+def test_validate_framework_clean_handoff_no_warnings(project_root: Path) -> None:
+    _minimal_layout(project_root)
+    (project_root / ".graphstack-framework").write_text("framework\n", encoding="utf-8")
+    (project_root / "handoff" / "BRIEF.md").write_text(
+        "# Brief: [Feature/Change Name]\n**Date:** YYYY-MM-DD\n",
+        encoding="utf-8",
+    )
+    report = run_checks()
+    assert not any(f.code.startswith("framework_") for f in report.findings)