test: add _resolve_version arg checks and _expand_flame unit tests

Verify exact subprocess.run arguments in _resolve_version tests to kill
string and kwarg mutations. Add _expand_flame unit tests for gap
distribution, style application, and boundary conditions. Add heat
indicator wave character tests for _build_fire_art.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: deviantintegral

tests/test_fireplace_visual.py

@@ -8,6 +8,7 @@
     _FLAME_PALETTES,
     _MIN_FLAME_ROWS,
     _build_fire_art,
+    _expand_flame,
     _rgbw_to_style,
 )
 
@@ -304,6 +305,92 @@ def test_all_palettes_defined(self):
 # ---------------------------------------------------------------------------
 
 
+# ---------------------------------------------------------------------------
+# _expand_flame – gap distribution
+# ---------------------------------------------------------------------------
+
+
+class TestExpandFlame:
+    """Tests for _expand_flame gap distribution."""
+
+    def test_basic_gap_distribution(self):
+        """Gaps are distributed proportionally among atoms."""
+        atoms = [("A", 1), ("B", 1), ("C", 0)]
+        result = _expand_flame(atoms, 13, "red")
+        plain = result.plain
+        # 3 chars of atoms, 10 chars of gap, split 5/5/0
+        assert len(plain) == 13
+        assert plain.startswith("A")
+        assert plain.endswith("C")
+
+    def test_style_applied(self):
+        """Atoms get the specified style."""
+        atoms = [("AB", 0)]
+        result = _expand_flame(atoms, 2, "bright_red")
+        styles = {str(s.style) for s in result._spans}
+        assert "bright_red" in styles
+
+    def test_gap_weight_zero_no_space(self):
+        """Atom with weight=0 gets no trailing gap."""
+        atoms = [("A", 1), ("B", 0)]
+        result = _expand_flame(atoms, 6, "red")
+        plain = result.plain
+        # Expect "A" + 4 spaces + "B" (no trailing space)
+        assert plain.endswith("B")
+        assert " " * 4 in plain
+
+    def test_exact_width_no_gaps(self):
+        """When body_width equals atom chars, no gaps added."""
+        atoms = [("AB", 1), ("CD", 0)]
+        result = _expand_flame(atoms, 4, "red")
+        assert result.plain == "ABCD"
+
+    def test_remaining_gap_decreases(self):
+        """Each atom consumes its proportional share of remaining gap."""
+        atoms = [("X", 2), ("Y", 1), ("Z", 0)]
+        result = _expand_flame(atoms, 12, "red")
+        plain = result.plain
+        assert len(plain) == 12
+        # X gets 2/3 of 9 gap = 6, Y gets 1/1 of 3 = 3
+        assert plain == "X" + " " * 6 + "Y" + " " * 3 + "Z"
+
+    def test_body_width_smaller_than_chars(self):
+        """When body_width < total atom chars, total_gap=0."""
+        atoms = [("ABCD", 1), ("EF", 0)]
+        result = _expand_flame(atoms, 3, "red")
+        assert result.plain == "ABCDEF"  # no gaps
+
+    def test_gap_spaces_not_other_chars(self):
+        """Gaps between atoms are regular spaces, not other characters."""
+        atoms = [("A", 1), ("B", 0)]
+        result = _expand_flame(atoms, 6, "red")
+        plain = result.plain
+        gap = plain[1:-1]
+        assert gap == " " * len(gap)
+
+
+# ---------------------------------------------------------------------------
+# _build_fire_art – heat rows
+# ---------------------------------------------------------------------------
+
+
+class TestBuildFireArtHeat:
+    """Tests for heat indicator rows in _build_fire_art."""
+
+    def test_heat_on_shows_wave_chars(self):
+        """Heat indicators include wave characters when heat_on=True."""
+        text = _build_fire_art(50, 20, heat_on=True)
+        plain = text.plain
+        assert "\u2248" in plain or "~" in plain
+
+    def test_heat_off_no_wave_chars(self):
+        """No wave characters when heat_on=False."""
+        text = _build_fire_art(50, 20, heat_on=False)
+        plain = text.plain
+        assert "\u2248" not in plain
+        assert "~" not in plain
+
+
 def _style_at(text, offset: int) -> str:
     """Return the style string applied to the character at *offset*."""
     for span in text._spans:

tests/test_tui_actions.py

@@ -1228,9 +1228,18 @@ def test_returns_version_when_tag_matches(self):
         from flameconnect import __version__
 
         tag_result = MagicMock(returncode=0, stdout=f"v{__version__}\n")
-        with patch("flameconnect.tui.app.subprocess.run", return_value=tag_result):
+        with patch(
+            "flameconnect.tui.app.subprocess.run", return_value=tag_result
+        ) as mock_run:
             result = _resolve_version()
         assert result == f"v{__version__}"
+        # Verify exact subprocess call
+        mock_run.assert_called_once_with(
+            ["git", "describe", "--tags", "--exact-match", "HEAD"],
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
 
     def test_returns_short_hash_when_no_tag(self):
         """When no matching tag, return the short git hash."""
@@ -1241,9 +1250,30 @@ def test_returns_short_hash_when_no_tag(self):
         with patch(
             "flameconnect.tui.app.subprocess.run",
             side_effect=[tag_result, hash_result, status_result],
-        ):
+        ) as mock_run:
             result = _resolve_version()
         assert result == "abc1234"
+        # Verify all three subprocess calls
+        assert mock_run.call_count == 3
+        calls = mock_run.call_args_list
+        assert calls[0].args[0] == [
+            "git",
+            "describe",
+            "--tags",
+            "--exact-match",
+            "HEAD",
+        ]
+        assert calls[1].args[0] == [
+            "git",
+            "rev-parse",
+            "--short",
+            "HEAD",
+        ]
+        assert calls[2].args[0] == ["git", "status", "--porcelain"]
+        for c in calls:
+            assert c.kwargs["capture_output"] is True
+            assert c.kwargs["text"] is True
+            assert c.kwargs["timeout"] == 2
 
     def test_returns_dirty_hash_when_uncommitted(self):
         """When working tree is dirty, append -dirty to the hash."""
@@ -1258,6 +1288,33 @@ def test_returns_dirty_hash_when_uncommitted(self):
             result = _resolve_version()
         assert result == "abc1234-dirty"
 
+    def test_clean_status_no_dirty_suffix(self):
+        """Clean status output should NOT append -dirty."""
+        tag_result = MagicMock(returncode=128, stdout="")
+        hash_result = MagicMock(returncode=0, stdout="abc1234\n")
+        status_result = MagicMock(returncode=0, stdout="")
+
+        with patch(
+            "flameconnect.tui.app.subprocess.run",
+            side_effect=[tag_result, hash_result, status_result],
+        ):
+            result = _resolve_version()
+        assert result == "abc1234"
+        assert "-dirty" not in result
+
+    def test_status_nonzero_returncode_no_dirty(self):
+        """Non-zero status returncode should not append -dirty."""
+        tag_result = MagicMock(returncode=128, stdout="")
+        hash_result = MagicMock(returncode=0, stdout="abc1234\n")
+        status_result = MagicMock(returncode=1, stdout="M some_file.py\n")
+
+        with patch(
+            "flameconnect.tui.app.subprocess.run",
+            side_effect=[tag_result, hash_result, status_result],
+        ):
+            result = _resolve_version()
+        assert result == "abc1234"
+
     def test_returns_version_when_hash_fails(self):
         """When git rev-parse fails, fall back to v{version}."""
         from flameconnect import __version__
@@ -1283,6 +1340,45 @@ def test_returns_version_on_exception(self):
             result = _resolve_version()
         assert result == f"v{__version__}"
 
+    def test_tag_returncode_nonzero_falls_through(self):
+        """Non-zero tag returncode means no tag match, proceed to hash."""
+        tag_result = MagicMock(returncode=1, stdout="")
+        hash_result = MagicMock(returncode=0, stdout="def5678\n")
+        status_result = MagicMock(returncode=0, stdout="")
+
+        with patch(
+            "flameconnect.tui.app.subprocess.run",
+            side_effect=[tag_result, hash_result, status_result],
+        ):
+            result = _resolve_version()
+        assert result == "def5678"
+
+    def test_tag_matches_but_version_not_in_output(self):
+        """Tag returncode=0 but version not in stdout falls through."""
+        tag_result = MagicMock(returncode=0, stdout="v99.99.99\n")
+        hash_result = MagicMock(returncode=0, stdout="aaa1111\n")
+        status_result = MagicMock(returncode=0, stdout="")
+
+        with patch(
+            "flameconnect.tui.app.subprocess.run",
+            side_effect=[tag_result, hash_result, status_result],
+        ):
+            result = _resolve_version()
+        assert result == "aaa1111"
+
+    def test_stdout_stripped(self):
+        """Trailing whitespace/newlines in stdout are stripped."""
+        tag_result = MagicMock(returncode=128, stdout="")
+        hash_result = MagicMock(returncode=0, stdout="  bbb2222  \n")
+        status_result = MagicMock(returncode=0, stdout="")
+
+        with patch(
+            "flameconnect.tui.app.subprocess.run",
+            side_effect=[tag_result, hash_result, status_result],
+        ):
+            result = _resolve_version()
+        assert result == "bbb2222"
+
 
 # ---------------------------------------------------------------------------
 # FireplaceCommandsProvider