cc-context-stats 1.8.0 → 1.8.2

package/tests/python/test_layout.py

@@ -1,127 +0,0 @@
-"""Tests for layout helpers (visible_width, get_terminal_width, fit_to_width)."""
-
-from unittest.mock import patch
-
-from claude_statusline.formatters.layout import (
-    fit_to_width,
-    get_terminal_width,
-    visible_width,
-)
-
-
-class TestVisibleWidth:
-    """Tests for visible_width()."""
-
-    def test_plain_text(self):
-        assert visible_width("hello") == 5
-
-    def test_ansi_colored_string(self):
-        s = "\033[0;32mgreen\033[0m"
-        assert visible_width(s) == 5
-
-    def test_multiple_ansi_codes(self):
-        s = "\033[2m[\033[0m\033[0;34mdir\033[0m"
-        assert visible_width(s) == 4  # [dir
-
-    def test_empty_string(self):
-        assert visible_width("") == 0
-
-    def test_unicode_icons(self):
-        assert visible_width("\u25cb") == 1  # ○
-        assert visible_width("\u26a1") == 1  # ⚡
-
-    def test_ansi_with_semicolons(self):
-        s = "\033[1;31;42mtext\033[0m"
-        assert visible_width(s) == 4
-
-
-class TestGetTerminalWidth:
-    """Tests for get_terminal_width()."""
-
-    def test_fallback_to_200_when_no_columns_env(self):
-        """When COLUMNS is not set and shutil returns 80, use 200 (Claude Code subprocess)."""
-        with (
-            patch("claude_statusline.formatters.layout.shutil.get_terminal_size") as mock,
-            patch.dict("os.environ", {}, clear=False),
-        ):
-            # Remove COLUMNS if present
-            import os
-
-            os.environ.pop("COLUMNS", None)
-            mock.return_value = type("Size", (), {"columns": 80})()
-            assert get_terminal_width() == 200
-
-    def test_respects_columns_env_80(self):
-        """When COLUMNS=80 is explicitly set, trust it."""
-        with (
-            patch("claude_statusline.formatters.layout.shutil.get_terminal_size") as mock,
-            patch.dict("os.environ", {"COLUMNS": "80"}),
-        ):
-            mock.return_value = type("Size", (), {"columns": 80})()
-            assert get_terminal_width() == 80
-
-    def test_custom_width(self):
-        with patch("claude_statusline.formatters.layout.shutil.get_terminal_size") as mock:
-            mock.return_value = type("Size", (), {"columns": 120})()
-            assert get_terminal_width() == 120
-
-
-class TestFitToWidth:
-    """Tests for fit_to_width()."""
-
-    def test_all_parts_fit(self):
-        parts = ["base", " | git", " | ctx"]
-        result = fit_to_width(parts, 80)
-        assert result == "base | git | ctx"
-
-    def test_drops_lowest_priority(self):
-        parts = ["base", " | git", " | ctx", " session-uuid-here"]
-        result = fit_to_width(parts, 25)
-        assert "base" in result
-        assert "session-uuid-here" not in result
-
-    def test_base_always_included(self):
-        parts = ["very-long-base-string-that-exceeds-width"]
-        result = fit_to_width(parts, 10)
-        assert result == "very-long-base-string-that-exceeds-width"
-
-    def test_empty_parts_skipped(self):
-        parts = ["base", "", " | ctx", "", " session"]
-        result = fit_to_width(parts, 30)
-        assert result == "base | ctx session"
-
-    def test_exact_boundary(self):
-        parts = ["12345", "67890"]
-        result = fit_to_width(parts, 10)
-        assert result == "1234567890"
-
-    def test_one_char_over_boundary(self):
-        parts = ["12345", "678901"]
-        result = fit_to_width(parts, 10)
-        assert result == "12345"
-
-    def test_empty_parts_list(self):
-        assert fit_to_width([], 80) == ""
-
-    def test_realistic_ansi_strings(self):
-        base = "\033[2m[Claude]\033[0m \033[0;34mdir\033[0m"
-        git = " | \033[0;35mmain\033[0m"
-        ctx = " | \033[0;32m150.0k (75.0%)\033[0m"
-        session = " \033[2mtest-session-uuid-1234\033[0m"
-
-        # base=[Claude] dir = 12, git= | main = 7, ctx= | 150.0k (75.0%) = 17,
-        # session= test-session-uuid-1234 = 23 => total = 59
-        result = fit_to_width([base, git, ctx, session], 80)
-        assert visible_width(result) == 59
-
-        # With tight width, session should be dropped
-        result = fit_to_width([base, git, ctx, session], 50)
-        assert "test-session-uuid-1234" not in result
-        assert visible_width(result) <= 50
-
-    def test_priority_order_preserved(self):
-        parts = ["base", " A", " B", " C", " D"]
-        # base=4, A=2, B=2, C=2, D=2 => total 12
-        # max_width=8 => base + A + B fits (8), C dropped, D dropped
-        result = fit_to_width(parts, 8)
-        assert result == "base A B"

package/tests/python/test_state_rotation_validation.py

@@ -1,232 +0,0 @@
-"""Tests for state file rotation and session ID validation."""
-
-import re
-import subprocess
-import sys
-
-import pytest
-
-from claude_statusline.core.state import StateFile, _validate_session_id
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _make_csv_line(index: int) -> str:
-    """Generate a deterministic CSV state line for a given index."""
-    return (
-        f"{1710288000 + index},100,200,300,400,500,600,0.01,"
-        f"10,5,sess-{index},model,/tmp/proj,200000"
-    )
-
-
-# ---------------------------------------------------------------------------
-# State File Rotation
-# ---------------------------------------------------------------------------
-
-
-class TestStateFileRotation:
-    """Tests for _maybe_rotate() in StateFile."""
-
-    def test_below_threshold_no_rotation(self, tmp_path, monkeypatch):
-        """File with fewer than 10,000 lines is not rotated."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        # Write 9,999 lines
-        lines = [_make_csv_line(i) + "\n" for i in range(9_999)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        result_lines = sf.file_path.read_text().splitlines()
-        assert len(result_lines) == 9_999
-
-    def test_at_threshold_no_rotation(self, tmp_path, monkeypatch):
-        """File with exactly 10,000 lines is not rotated."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        lines = [_make_csv_line(i) + "\n" for i in range(10_000)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        result_lines = sf.file_path.read_text().splitlines()
-        assert len(result_lines) == 10_000
-
-    def test_exceeds_threshold_truncates_to_5000(self, tmp_path, monkeypatch):
-        """File with 10,001 lines is truncated to 5,000."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        lines = [_make_csv_line(i) + "\n" for i in range(10_001)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        result_lines = sf.file_path.read_text().splitlines()
-        assert len(result_lines) == 5_000
-
-    def test_retained_lines_are_most_recent(self, tmp_path, monkeypatch):
-        """After rotation, the retained lines are the last 5,000 of the original."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        total = 10_001
-        lines = [_make_csv_line(i) + "\n" for i in range(total)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        result_lines = sf.file_path.read_text().splitlines()
-        # First retained line should be the one at index (total - 5000) = 5001
-        assert f"sess-{total - 5000}" in result_lines[0]
-        # Last retained line should be the last original line
-        assert f"sess-{total - 1}" in result_lines[-1]
-
-    def test_rotation_via_append_entry(self, tmp_path, monkeypatch):
-        """append_entry triggers rotation when threshold is exceeded."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        # Write exactly 10,000 lines (at threshold, no rotation yet)
-        lines = [_make_csv_line(i) + "\n" for i in range(10_000)]
-        sf.file_path.write_text("".join(lines))
-
-        # Import StateEntry to create a valid entry
-        from claude_statusline.core.state import StateEntry
-
-        entry = StateEntry(
-            timestamp=1710298000,
-            total_input_tokens=100,
-            total_output_tokens=200,
-            current_input_tokens=300,
-            current_output_tokens=400,
-            cache_creation=500,
-            cache_read=600,
-            cost_usd=0.01,
-            lines_added=10,
-            lines_removed=5,
-            session_id="test-session",
-            model_id="model",
-            workspace_project_dir="/tmp/proj",
-            context_window_size=200000,
-        )
-        sf.append_entry(entry)
-
-        # Now file had 10,001 lines -> should have been rotated to 5,000
-        result_lines = sf.file_path.read_text().splitlines()
-        assert len(result_lines) == 5_000
-
-    def test_no_temp_files_left_after_rotation(self, tmp_path, monkeypatch):
-        """No .tmp files remain after successful rotation."""
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("test-session")
-        lines = [_make_csv_line(i) + "\n" for i in range(10_001)]
-        sf.file_path.write_text("".join(lines))
-
-        sf._maybe_rotate()
-
-        tmp_files = list(tmp_path.glob("*.tmp"))
-        assert tmp_files == []
-
-
-# ---------------------------------------------------------------------------
-# Session ID Validation
-# ---------------------------------------------------------------------------
-
-
-class TestSessionIdValidation:
-    """Tests for _validate_session_id and StateFile constructor validation."""
-
-    def test_reject_forward_slash(self):
-        with pytest.raises(ValueError, match="/"):
-            _validate_session_id("../../etc/passwd")
-
-    def test_reject_backslash(self):
-        with pytest.raises(ValueError, match=re.escape("\\")):
-            _validate_session_id("..\\..\\etc\\passwd")
-
-    def test_reject_dot_dot(self):
-        with pytest.raises(ValueError, match=r"\.\."):
-            _validate_session_id("..hidden")
-
-    def test_reject_null_byte(self):
-        with pytest.raises(ValueError):
-            _validate_session_id("session\0id")
-
-    def test_accept_valid_uuid(self):
-        _validate_session_id("abc-123-def-456")  # Should not raise
-
-    def test_accept_hyphens_underscores(self):
-        _validate_session_id("my_session-id_123")  # Should not raise
-
-    def test_accept_alphanumeric(self):
-        _validate_session_id("abcdef1234567890")  # Should not raise
-
-    def test_statefile_rejects_invalid_session(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        with pytest.raises(ValueError):
-            StateFile("../../etc/passwd")
-
-    def test_statefile_accepts_none_session(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile(None)  # Should not raise
-        assert sf.session_id is None
-
-    def test_statefile_accepts_valid_session(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(StateFile, "STATE_DIR", tmp_path)
-        monkeypatch.setattr(StateFile, "OLD_STATE_DIR", tmp_path / "old")
-        (tmp_path / "old").mkdir()
-
-        sf = StateFile("valid-session-123")  # Should not raise
-        assert sf.session_id == "valid-session-123"
-
-
-# ---------------------------------------------------------------------------
-# CLI Session ID Rejection (subprocess test)
-# ---------------------------------------------------------------------------
-
-
-class TestCliSessionIdRejection:
-    """Test that context-stats CLI rejects invalid session IDs."""
-
-    def test_cli_rejects_path_traversal(self):
-        result = subprocess.run(
-            [sys.executable, "-m", "claude_statusline.cli.context_stats", "../../etc/passwd"],
-            capture_output=True,
-            text=True,
-        )
-        assert result.returncode != 0
-        assert "Invalid session_id" in result.stderr
-
-    def test_cli_rejects_backslash(self):
-        result = subprocess.run(
-            [sys.executable, "-m", "claude_statusline.cli.context_stats", "test\\bad"],
-            capture_output=True,
-            text=True,
-        )
-        assert result.returncode != 0
-        assert "Invalid session_id" in result.stderr

package/tests/python/test_statusline.py

@@ -1,215 +0,0 @@
-"""Tests for statusline.py script."""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-SCRIPT_PATH = Path(__file__).parent.parent.parent / "scripts" / "statusline.py"
-
-_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
-
-
-def strip_ansi(s: str) -> str:
-    """Strip ANSI escape sequences from a string."""
-    return _ANSI_RE.sub("", s)
-
-
-def run_script(input_data: dict, env_overrides: dict | None = None) -> tuple[str, int]:
-    """Run the statusline.py script with the given input.
-
-    Args:
-        input_data: JSON-serializable dict to pass as stdin.
-        env_overrides: Optional dict of environment variable overrides.
-
-    Returns:
-        Tuple of (stdout, return_code)
-    """
-    env = os.environ.copy()
-    env["PYTHONUTF8"] = "1"
-    if env_overrides:
-        env.update(env_overrides)
-    result = subprocess.run(
-        [sys.executable, str(SCRIPT_PATH)],
-        input=json.dumps(input_data),
-        capture_output=True,
-        text=True,
-        env=env,
-    )
-    return result.stdout.strip(), result.returncode
-
-
-class TestStatuslineScript:
-    """Tests for the statusline.py script execution."""
-
-    def test_script_exists(self):
-        """Script file should exist."""
-        assert SCRIPT_PATH.exists()
-
-    def test_script_is_python(self):
-        """Script should have Python shebang."""
-        content = SCRIPT_PATH.read_text(encoding="utf-8")
-        assert content.startswith("#!/usr/bin/env python3")
-
-    def test_outputs_model_name(self, sample_input):
-        """Should output the model name."""
-        output, code = run_script(sample_input)
-        assert code == 0
-        assert "Claude 3.5 Sonnet" in output
-
-    def test_outputs_directory_name(self, sample_input):
-        """Should output the directory name."""
-        output, code = run_script(sample_input)
-        assert code == 0
-        assert "myproject" in output
-
-    def test_shows_free_tokens(self, sample_input):
-        """Should show free tokens indicator."""
-        output, code = run_script(sample_input)
-        assert code == 0
-        assert "%" in output
-
-    def test_shows_ac_indicator(self, sample_input):
-        """Should show autocompact indicator."""
-        output, code = run_script(sample_input)
-        assert code == 0
-        assert "[AC:" in output
-
-    def test_handles_missing_model(self):
-        """Should handle missing model gracefully."""
-        input_data = {"workspace": {"current_dir": "/tmp/test", "project_dir": "/tmp/test"}}
-        output, code = run_script(input_data)
-        assert code == 0
-        assert "Claude" in output  # Default fallback
-
-    def test_handles_invalid_json(self):
-        """Should handle invalid JSON gracefully."""
-        env = os.environ.copy()
-        env["PYTHONUTF8"] = "1"
-        result = subprocess.run(
-            [sys.executable, str(SCRIPT_PATH)],
-            input="invalid json",
-            capture_output=True,
-            text=True,
-            env=env,
-        )
-        assert result.returncode == 0
-        assert "Claude" in result.stdout
-
-    def test_handles_empty_input(self):
-        """Should handle empty input gracefully."""
-        env = os.environ.copy()
-        env["PYTHONUTF8"] = "1"
-        result = subprocess.run(
-            [sys.executable, str(SCRIPT_PATH)],
-            input="",
-            capture_output=True,
-            text=True,
-            env=env,
-        )
-        assert result.returncode == 0
-
-
-class TestContextWindowColors:
-    """Tests for context window color coding."""
-
-    def test_low_usage_has_output(self, low_usage_input):
-        """Low usage (>50% free) should produce output with 'free'."""
-        output, code = run_script(low_usage_input)
-        assert code == 0
-        assert "%" in output
-
-    def test_medium_usage_has_output(self, medium_usage_input):
-        """Medium usage (25-50% free) should produce output with 'free'."""
-        output, code = run_script(medium_usage_input)
-        assert code == 0
-        assert "%" in output
-
-    def test_high_usage_has_output(self, high_usage_input):
-        """High usage (<25% free) should produce output with 'free'."""
-        output, code = run_script(high_usage_input)
-        assert code == 0
-        assert "%" in output
-
-
-class TestFixtures:
-    """Tests using fixture files."""
-
-    def test_valid_full_fixture(self, valid_full_input):
-        """Should handle valid_full.json fixture."""
-        output, code = run_script(valid_full_input)
-        assert code == 0
-        assert "Opus 4.5" in output
-        assert "my-project" in output
-
-    def test_valid_minimal_fixture(self, valid_minimal_input):
-        """Should handle valid_minimal.json fixture."""
-        output, code = run_script(valid_minimal_input)
-        assert code == 0
-        assert "Claude" in output
-
-    def test_all_fixtures_succeed(self, fixtures_dir):
-        """All JSON fixtures should be processed without errors."""
-        for fixture_file in fixtures_dir.glob("*.json"):
-            with open(fixture_file) as f:
-                input_data = json.load(f)
-            output, code = run_script(input_data)
-            assert code == 0, f"Failed on fixture: {fixture_file.name}"
-
-
-class TestSessionDisplay:
-    """Tests for session_id display feature."""
-
-    def test_shows_session_id_by_default(self, sample_input):
-        """Should show session_id by default (show_session=true)."""
-        sample_input["session_id"] = "test-session-12345"
-        output, code = run_script(sample_input, {"COLUMNS": "200"})
-        assert code == 0
-        assert "test-session-12345" in output
-
-    def test_handles_missing_session_id(self, sample_input):
-        """Should handle missing session_id gracefully."""
-        # Ensure no session_id in input
-        if "session_id" in sample_input:
-            del sample_input["session_id"]
-        output, code = run_script(sample_input)
-        assert code == 0
-
-
-class TestWidthTruncation:
-    """Tests for width truncation to fit terminal width."""
-
-    def test_output_fits_80_columns(self, sample_input):
-        """Output should fit within 80 columns."""
-        sample_input["session_id"] = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
-        output, code = run_script(sample_input, {"COLUMNS": "80"})
-        assert code == 0
-        visible = strip_ansi(output)
-        assert len(visible) <= 80
-
-    def test_output_fits_narrow_terminal(self, sample_input):
-        """Output should fit within 40 columns and still show model+dir."""
-        output, code = run_script(sample_input, {"COLUMNS": "40"})
-        assert code == 0
-        visible = strip_ansi(output)
-        assert len(visible) <= 40
-        assert "Claude 3.5 Sonnet" in visible
-        assert "myproject" in visible
-
-    def test_wide_terminal_shows_all(self, sample_input):
-        """Wide terminal should show session_id."""
-        sample_input["session_id"] = "test-wide-session-uuid"
-        output, code = run_script(sample_input, {"COLUMNS": "200"})
-        assert code == 0
-        assert "test-wide-session-uuid" in output
-
-    def test_full_input_truncated(self, valid_full_input):
-        """Full input with all features should fit within 80 columns."""
-        output, code = run_script(valid_full_input, {"COLUMNS": "80"})
-        assert code == 0
-        visible = strip_ansi(output)
-        assert len(visible) <= 80