"""Testsuite for libtmux hook management.""" from __future__ import annotations import typing as t import pytest from libtmux._internal.constants import Hooks from libtmux._internal.sparse_array import SparseArray from libtmux.common import has_gte_version if t.TYPE_CHECKING: from libtmux.server import Server def test_hooks_raw_cmd( server: Server, ) -> None: """Raw hook set, show, unset via cmd.""" session = server.new_session(session_name="test hooks") window = session.attached_window pane = window.attached_pane assert pane is not None # # Global # set_hook_proc = server.cmd( "set-hook", "-g", "session-renamed[0]", "set -g status-left-style bg=red", ) assert not set_hook_proc.stdout assert not set_hook_proc.stderr assert not server.cmd("show-hooks").stdout show_hooks_proc = server.cmd("show-hooks", "-g", "session-renamed[0]") assert "set-option -g status-left-style bg=red" in show_hooks_proc.stdout[0] # Server: Unset # Server: Unset: Index set_hook_proc = server.cmd( "set-hook", "-g", "-u", "session-renamed[0]", ) assert server.cmd("show-hooks", "-g", "session-renamed[0]").stdout == [ "session-renamed[0] ", ] # Server: Unset variable set_hook_proc = server.cmd( "set-hook", "-g", "-u", "session-renamed", ) assert server.cmd("show-hooks", "-g", "session-renamed[0]").stdout == [ "session-renamed[0] ", ] # # Session # set_hook_proc = session.cmd( "set-hook", "session-renamed[0]", "set -g status-left-style bg=red", ) assert not set_hook_proc.stdout assert not set_hook_proc.stderr assert not session.cmd( "show-hooks", "-s", ).stdout show_hooks_proc = session.cmd( "show-hooks", "session-renamed[0]", ) assert "set-option -g status-left-style bg=red" in show_hooks_proc.stdout[0] # Session: Unset # Session: Unset: Index set_hook_proc = session.cmd( "set-hook", "-u", "session-renamed[0]", ) assert session.cmd("show-hooks", "-s", "session-renamed[0]").stdout == [] # Session: Unset variable set_hook_proc = session.cmd( "set-hook", "-u", "session-renamed", ) assert session.cmd("show-hooks", "-s", "session-renamed[0]").stdout == [] if has_gte_version("3.2"): # # Window # set_hook_proc = window.cmd( "set-hook", "-w", "session-renamed[0]", "set -g status-left-style bg=red", ) assert not set_hook_proc.stdout assert not set_hook_proc.stderr show_hooks_proc = server.cmd( "show-hooks", "session-renamed[0]", ) assert "set-option -g status-left-style bg=red" in show_hooks_proc.stdout[0] # Window: Unset # Window: Unset: Index set_hook_proc = window.cmd( "set-hook", "-w", "-u", "session-renamed[0]", ) assert window.cmd("show-hooks", "-w", "session-renamed[0]").stdout == [ "session-renamed[0] ", ] # Window: Unset variable set_hook_proc = window.cmd( "set-hook", "-w", "-u", "session-renamed", ) assert window.cmd("show-hooks", "-w", "session-renamed[0]").stdout == [] # # Pane # set_hook_proc = pane.cmd( "set-hook", "-p", "session-renamed[0]", "set -g status-left-style bg=red", ) assert not set_hook_proc.stdout assert not set_hook_proc.stderr show_hooks_proc = server.cmd( "show-hooks", "-p", "session-renamed[0]", ) assert "set-option -g status-left-style bg=red" in show_hooks_proc.stdout[0] # Pane: Unset # Pane: Unset: Index set_hook_proc = pane.cmd( "set-hook", "-p", "-u", "session-renamed[0]", ) assert pane.cmd("show-hooks", "-p", "session-renamed[0]").stdout == [ "session-renamed[0] ", ] # Pane: Unset variable set_hook_proc = pane.cmd( "set-hook", "-p", "-u", "session-renamed", ) assert pane.cmd("show-hooks", "-p", "session-renamed[0]").stdout == [] def test_hooks_dataclass( server: Server, ) -> None: """Tests for hooks dataclass.""" session = server.new_session(session_name="test hooks") window = session.attached_window pane = window.attached_pane assert pane is not None # # Session # set_hook_proc = session.cmd( "set-hook", "session-renamed[0]", "set -g status-left-style bg=red", ) assert not set_hook_proc.stdout assert not set_hook_proc.stderr show_hooks_proc = server.cmd( "show-hooks", "session-renamed[0]", ) hooks = Hooks.from_stdout(show_hooks_proc.stdout) assert hooks.session_renamed.as_list() == [ "set-option -g status-left-style bg=red", ] set_hook_proc = session.cmd( "set-hook", "-p", "session-renamed[0]", "set -g status-left-style bg=red", ) set_hook_proc = session.cmd( "set-hook", "session-renamed[1]", "set -g status-left-style bg=white", ) set_hook_proc = session.cmd( "set-hook", "session-renamed[2]", "set -g status-left-style bg=blue", ) set_hook_proc = session.cmd( "set-hook", "after-set-buffer[2]", "set -g status-left-style bg=pink", ) global_out = server.cmd("show-hooks", "-g").stdout session_out = server.cmd("show-hooks").stdout window_out = server.cmd("show-hooks", "-w").stdout pane_out = server.cmd("show-hooks", "-p").stdout session_out_processed = Hooks.from_stdout(session_out) assert session_out_processed.session_renamed is not None assert ( session_out_processed.session_renamed[2] == "set-option -g status-left-style bg=blue" ) hooks = Hooks.from_stdout(global_out + session_out + window_out + pane_out) assert hooks.session_renamed.as_list() == [ "set-option -g status-left-style bg=red", "set-option -g status-left-style bg=white", "set-option -g status-left-style bg=blue", ] assert hooks.after_set_buffer.as_list() == [ "set-option -g status-left-style bg=pink", ] def test_hooks_mixin( server: Server, ) -> None: """Tests for hooks.""" session = server.new_session(session_name="test hooks") window = session.attached_window pane = window.attached_pane assert pane is not None pane.set_hook("session-renamed[0]", "set -g status-left-style bg=red") # # Pane # assert not pane.show_hooks() show_hooks_raw = pane._show_hook( "session-renamed[0]", ) assert show_hooks_raw is not None hooks = Hooks.from_stdout(show_hooks_raw) assert hooks.session_renamed == SparseArray( { 0: "set-option -g status-left-style bg=red", }, ) # ============================================================================= # Comprehensive Hook Test Grid # ============================================================================= class HookTestCase(t.NamedTuple): """Test case for hook validation.""" test_id: str hook: str # tmux hook name (hyphenated) min_version: str = "3.0" # Minimum tmux version required xfail_reason: str | None = None # Mark as expected failure with reason # --- Alert Hooks --- ALERT_HOOKS: list[HookTestCase] = [ HookTestCase("alert_activity", "alert-activity"), HookTestCase("alert_bell", "alert-bell"), HookTestCase("alert_silence", "alert-silence"), ] # --- Client Hooks --- CLIENT_HOOKS: list[HookTestCase] = [ HookTestCase("client_active", "client-active", "3.3"), HookTestCase("client_attached", "client-attached"), HookTestCase("client_detached", "client-detached"), HookTestCase("client_focus_in", "client-focus-in", "3.3"), HookTestCase("client_focus_out", "client-focus-out", "3.3"), HookTestCase("client_resized", "client-resized"), HookTestCase("client_session_changed", "client-session-changed"), ] # --- Session Hooks --- SESSION_HOOKS: list[HookTestCase] = [ HookTestCase("session_created", "session-created"), HookTestCase("session_closed", "session-closed"), HookTestCase("session_renamed", "session-renamed"), ] # --- Window Hooks --- WINDOW_HOOKS: list[HookTestCase] = [ HookTestCase("window_linked", "window-linked"), HookTestCase("window_renamed", "window-renamed"), HookTestCase("window_resized", "window-resized", "3.3"), HookTestCase("window_unlinked", "window-unlinked"), HookTestCase("session_window_changed", "session-window-changed"), ] # --- Pane Hooks --- PANE_HOOKS: list[HookTestCase] = [ HookTestCase("pane_died", "pane-died"), HookTestCase("pane_exited", "pane-exited"), HookTestCase("pane_focus_in", "pane-focus-in"), HookTestCase("pane_focus_out", "pane-focus-out"), HookTestCase("pane_mode_changed", "pane-mode-changed"), HookTestCase("pane_set_clipboard", "pane-set-clipboard"), ] # --- After-* Hooks --- AFTER_HOOKS: list[HookTestCase] = [ HookTestCase("after_bind_key", "after-bind-key"), HookTestCase("after_capture_pane", "after-capture-pane"), HookTestCase("after_copy_mode", "after-copy-mode"), HookTestCase("after_display_message", "after-display-message"), HookTestCase("after_display_panes", "after-display-panes"), HookTestCase("after_kill_pane", "after-kill-pane"), HookTestCase("after_list_buffers", "after-list-buffers"), HookTestCase("after_list_clients", "after-list-clients"), HookTestCase("after_list_keys", "after-list-keys"), HookTestCase("after_list_panes", "after-list-panes"), HookTestCase("after_list_sessions", "after-list-sessions"), HookTestCase("after_list_windows", "after-list-windows"), HookTestCase("after_load_buffer", "after-load-buffer"), HookTestCase("after_lock_server", "after-lock-server"), HookTestCase("after_new_session", "after-new-session"), HookTestCase("after_new_window", "after-new-window"), HookTestCase("after_paste_buffer", "after-paste-buffer"), HookTestCase("after_pipe_pane", "after-pipe-pane"), HookTestCase("after_queue", "after-queue"), HookTestCase("after_refresh_client", "after-refresh-client"), HookTestCase("after_rename_session", "after-rename-session"), HookTestCase("after_rename_window", "after-rename-window"), HookTestCase("after_resize_pane", "after-resize-pane"), HookTestCase("after_resize_window", "after-resize-window"), HookTestCase("after_save_buffer", "after-save-buffer"), HookTestCase("after_select_layout", "after-select-layout"), HookTestCase("after_select_pane", "after-select-pane"), HookTestCase("after_select_window", "after-select-window"), HookTestCase("after_send_keys", "after-send-keys"), HookTestCase("after_set_buffer", "after-set-buffer"), HookTestCase("after_set_environment", "after-set-environment"), HookTestCase("after_set_hook", "after-set-hook"), HookTestCase("after_set_option", "after-set-option"), HookTestCase("after_show_environment", "after-show-environment"), HookTestCase("after_show_messages", "after-show-messages"), HookTestCase("after_show_options", "after-show-options"), HookTestCase("after_split_window", "after-split-window"), HookTestCase("after_unbind_key", "after-unbind-key"), ] # --- New Hooks (tmux 3.5+) --- NEW_HOOKS: list[HookTestCase] = [ HookTestCase( "pane_title_changed", "pane-title-changed", "3.5", ), # NOTE: client-light-theme and client-dark-theme are not in any released tmux # version yet (will be in 3.6+). Add them back when 3.6 is released. ] # Combine all hook test cases ALL_HOOK_TEST_CASES: list[HookTestCase] = ( ALERT_HOOKS + CLIENT_HOOKS + SESSION_HOOKS + WINDOW_HOOKS + PANE_HOOKS + AFTER_HOOKS ) def _build_hook_params() -> list[t.Any]: """Build pytest params with appropriate marks.""" params = [] for tc in ALL_HOOK_TEST_CASES: marks: list[t.Any] = [] if tc.xfail_reason: marks.append(pytest.mark.xfail(reason=tc.xfail_reason)) params.append(pytest.param(tc, id=tc.test_id, marks=marks)) return params @pytest.mark.parametrize("test_case", _build_hook_params()) def test_hook_set_show_unset_cycle(server: Server, test_case: HookTestCase) -> None: """Test set/show/unset cycle for each hook. This parametrized test ensures all hooks in the libtmux constants can be: 1. Set with a command 2. Shown and verified 3. Unset cleanly """ if not has_gte_version(test_case.min_version): pytest.skip(f"Requires tmux {test_case.min_version}+") session = server.new_session(session_name="test_hook_cycle") window = session.active_window assert window is not None pane = window.active_pane assert pane is not None hook_cmd = "display-message 'test hook fired'" # Test set_hook (using session-level hook which works on all tmux versions) session.set_hook(f"{test_case.hook}[0]", hook_cmd) # Test show_hook result = session._show_hook(f"{test_case.hook}[0]") assert result is not None, f"Expected hook {test_case.hook} to be set" # Parse and verify hooks = Hooks.from_stdout(result) hook_attr = test_case.hook.replace("-", "_") hook_value = getattr(hooks, hook_attr, None) assert hook_value is not None, f"Hook attribute {hook_attr} not found in Hooks" assert len(hook_value) > 0, f"Expected hook {test_case.hook} to have values" assert "display-message" in hook_value[0], ( f"Expected 'display-message' in hook value, got: {hook_value[0]}" ) # Test unset_hook session.unset_hook(f"{test_case.hook}[0]") # Verify unset result_after_unset = session._show_hook(f"{test_case.hook}[0]") if result_after_unset: hooks_after = Hooks.from_stdout(result_after_unset) hook_value_after = getattr(hooks_after, hook_attr, None) # After unset, the hook should be empty or have empty value if hook_value_after: assert len(hook_value_after.as_list()) == 0 or hook_value_after[0] == "", ( f"Expected hook {test_case.hook} to be unset" ) @pytest.mark.parametrize( "test_case", [pytest.param(tc, id=tc.test_id) for tc in NEW_HOOKS], ) def test_new_hooks_version_gated(server: Server, test_case: HookTestCase) -> None: """Test new hooks that require tmux 3.5+. These hooks are version-gated and will skip on older tmux versions. """ if not has_gte_version(test_case.min_version): pytest.skip(f"Requires tmux {test_case.min_version}+") session = server.new_session(session_name="test_new_hooks") hook_cmd = "display-message 'new hook fired'" # Test set_hook session.set_hook(f"{test_case.hook}[0]", hook_cmd) # Test show_hook result = session._show_hook(f"{test_case.hook}[0]") assert result is not None, f"Expected hook {test_case.hook} to be set" # Cleanup session.unset_hook(f"{test_case.hook}[0]") # ============================================================================= # set_hooks Tests # ============================================================================= class SetHooksTestCase(t.NamedTuple): """Test case for set_hooks operations.""" test_id: str hook: str # Hook name to test setup_hooks: dict[int, str] # Initial hooks to set (index -> value) operation_args: dict[str, t.Any] # Args for set_hooks expected_indices: list[int] # Expected indices after operation expected_contains: list[str] | None = None # Strings expected in values SET_HOOKS_TESTS: list[SetHooksTestCase] = [ SetHooksTestCase( "set_hooks_with_dict", "session-renamed", {}, { "values": { 0: "display-message 'hook 0'", 1: "display-message 'hook 1'", 5: "display-message 'hook 5'", }, }, [0, 1, 5], ["hook 0", "hook 1", "hook 5"], ), SetHooksTestCase( "set_hooks_with_list", "session-renamed", {}, { "values": [ "display-message 'hook 0'", "display-message 'hook 1'", "display-message 'hook 2'", ], }, [0, 1, 2], ), SetHooksTestCase( "set_hooks_clear_existing", "session-renamed", {0: "display-message 'old 0'", 1: "display-message 'old 1'"}, {"values": {0: "display-message 'new 0'"}, "clear_existing": True}, [0], ["new 0"], ), ] def _build_set_hooks_params() -> list[t.Any]: """Build pytest params for set_hooks tests.""" return [pytest.param(tc, id=tc.test_id) for tc in SET_HOOKS_TESTS] @pytest.mark.parametrize("test_case", _build_set_hooks_params()) def test_set_hooks(server: Server, test_case: SetHooksTestCase) -> None: """Test set_hooks operations.""" session = server.new_session(session_name="test_set_hooks") # Setup initial hooks for idx, val in test_case.setup_hooks.items(): session.set_hook(f"{test_case.hook}[{idx}]", val) # Perform set_hooks session.set_hooks(test_case.hook, **test_case.operation_args) # Verify via show_hook hooks = session.show_hook(test_case.hook) assert hooks is not None assert isinstance(hooks, SparseArray) assert sorted(hooks.keys()) == test_case.expected_indices if test_case.expected_contains: for expected_str in test_case.expected_contains: assert any(expected_str in v for v in hooks.values()) # Cleanup session.unset_hook(test_case.hook) def test_show_hook_returns_sparse_array(server: Server) -> None: """Test that show_hook returns SparseArray for array hooks.""" session = server.new_session(session_name="test_show_hook") # Set hooks at sparse indices (out of order) session.set_hook("session-renamed[5]", "display-message 'fifth'") session.set_hook("session-renamed[0]", "display-message 'zeroth'") session.set_hook("session-renamed[2]", "display-message 'second'") hooks = session.show_hook("session-renamed") assert hooks is not None assert isinstance(hooks, SparseArray) # Check keys (indices) assert sorted(hooks.keys()) == [0, 2, 5] # Check values via iter_values (sorted order) value_list = list(hooks.iter_values()) assert len(value_list) == 3 assert "zeroth" in value_list[0] assert "second" in value_list[1] assert "fifth" in value_list[2] # Cleanup session.unset_hook("session-renamed") class IndexedHookLookupCase(t.NamedTuple): """Test fixture for indexed hook lookups.""" test_id: str hook_name: str hook_index: int hook_value: str @pytest.mark.parametrize( IndexedHookLookupCase._fields, [ IndexedHookLookupCase( test_id="index_zero", hook_name="session-renamed", hook_index=0, hook_value="display-message 'test zero'", ), IndexedHookLookupCase( test_id="index_five", hook_name="session-renamed", hook_index=5, hook_value="display-message 'test five'", ), IndexedHookLookupCase( test_id="window_hook", hook_name="window-renamed", hook_index=0, hook_value="display-message 'window test'", ), ], ids=lambda x: x.test_id if isinstance(x, IndexedHookLookupCase) else x, ) def test_show_hook_indexed_lookup( server: Server, test_id: str, hook_name: str, hook_index: int, hook_value: str, ) -> None: """Test that show_hook with indexed hook name returns the specific value. Per tmux.1, hooks are array options that can be queried by index. When calling show_hook("session-renamed[0]"), it should return the string value at that index, not a SparseArray. """ session = server.new_session(session_name="test_indexed_lookup") indexed_hook = f"{hook_name}[{hook_index}]" # Set the hook session.set_hook(indexed_hook, hook_value) # Query with indexed name - should return the specific value, not SparseArray result = session.show_hook(indexed_hook) assert result is not None assert isinstance(result, str), f"Expected str, got {type(result)}" # tmux may normalize quotes, so check the essential parts are present assert "display-message" in result # Verify base hook query still returns SparseArray base_result = session.show_hook(hook_name) assert isinstance(base_result, SparseArray) assert hook_index in base_result # Cleanup session.unset_hook(hook_name) def test_set_hooks_with_sparse_array(server: Server) -> None: """Test set_hooks with SparseArray input.""" session = server.new_session(session_name="test_set_hooks_sparse") sparse: SparseArray[str] = SparseArray() sparse.add(0, "display-message 'from sparse 0'") sparse.add(10, "display-message 'from sparse 10'") session.set_hooks("session-renamed", sparse) hooks = session.show_hook("session-renamed") assert hooks is not None assert isinstance(hooks, SparseArray) assert sorted(hooks.keys()) == [0, 10] # Cleanup session.unset_hook("session-renamed") def test_set_hooks_method_chaining(server: Server) -> None: """Test that set_hooks supports method chaining.""" session = server.new_session(session_name="test_set_hooks_chain") # Chain set_hooks with set_hook (append=True) result = ( session.set_hooks( "session-renamed", ["display-message 'hook 0'"], ) .set_hook("session-renamed", "display-message 'hook 1'", append=True) .set_hook("session-renamed", "display-message 'hook 2'", append=True) ) # Should return the session assert result is session # Verify all hooks set via show_hook hooks = session.show_hook("session-renamed") assert hooks is not None assert isinstance(hooks, SparseArray) assert sorted(hooks.keys()) == [0, 1, 2] # Cleanup session.unset_hook("session-renamed") def test_unset_hook_clears_all_indices(server: Server) -> None: """Test that unset_hook without index clears all hook indices.""" session = server.new_session(session_name="test_unset_hook") # Set hooks at multiple indices session.set_hook("session-renamed[0]", "display-message 'hook 0'") session.set_hook("session-renamed[5]", "display-message 'hook 5'") session.set_hook("session-renamed[10]", "display-message 'hook 10'") # Verify hooks exist hooks = session.show_hook("session-renamed") assert hooks is not None assert isinstance(hooks, SparseArray) assert sorted(hooks.keys()) == [0, 5, 10] # Unset without index should clear all session.unset_hook("session-renamed") # Verify hooks are cleared hooks_after = session.show_hook("session-renamed") assert hooks_after is None or ( isinstance(hooks_after, SparseArray) and len(hooks_after) == 0 ) def test_set_hook_append_flag(server: Server) -> None: """Test set_hook with append=True uses tmux's -a flag.""" session = server.new_session(session_name="test_append_flag") # Set initial hook session.set_hook("session-renamed[0]", "display-message 'initial'") # Append using set_hook with append=True session.set_hook("session-renamed", "display-message 'appended'", append=True) # Verify both hooks exist hooks = session.show_hook("session-renamed") assert hooks is not None assert isinstance(hooks, SparseArray) assert len(hooks) == 2 # Cleanup session.unset_hook("session-renamed") # ============================================================================= # show_hooks Tests # ============================================================================= class ShowHooksTestCase(t.NamedTuple): """Test case for show_hooks validation.""" test_id: str hook: str value: str expected_value: str expected_type: type min_version: str = "3.2" SHOW_HOOKS_TEST_CASES: list[ShowHooksTestCase] = [ ShowHooksTestCase( test_id="string_hook_value", hook="session-renamed[0]", value='display-message "test"', expected_value="display-message test", # tmux strips quotes in output expected_type=str, ), ShowHooksTestCase( test_id="multiple_hooks", hook="session-renamed[1]", value='display-message "another"', expected_value="display-message another", # tmux strips quotes in output expected_type=str, ), ] def _build_show_hooks_params() -> list[t.Any]: """Build pytest params for show_hooks tests.""" return [pytest.param(tc, id=tc.test_id) for tc in SHOW_HOOKS_TEST_CASES] @pytest.mark.parametrize("test_case", _build_show_hooks_params()) def test_show_hooks_stores_string_values( server: Server, test_case: ShowHooksTestCase, ) -> None: """Test that show_hooks() correctly stores string hook values.""" if not has_gte_version(test_case.min_version): pytest.skip(f"Requires tmux >= {test_case.min_version}") session = server.new_session(session_name="test_show_hooks") session.set_hook(test_case.hook, test_case.value) hooks = session.show_hooks() assert test_case.hook in hooks assert isinstance(hooks[test_case.hook], test_case.expected_type) assert hooks[test_case.hook] == test_case.expected_value # Cleanup session.unset_hook(test_case.hook.split("[")[0]) # ============================================================================= # run_hook Tests # ============================================================================= def test_run_hook_basic(server: Server) -> None: """Test run_hook() method exists and can be called without error.""" if not has_gte_version("3.2"): pytest.skip("Requires tmux >= 3.2") session = server.new_session(session_name="test_run_hook") # Set a hook first session.set_hook("session-renamed[0]", 'display-message "test"') # Run the hook immediately - should not raise result = session.run_hook("session-renamed[0]") # Verify returns self for chaining assert result is session # Cleanup session.unset_hook("session-renamed") # ============================================================================= # set_hook Flag Combination Tests # ============================================================================= class SetHookFlagTestCase(t.NamedTuple): """Test case for set_hook flag combinations.""" test_id: str flag_kwargs: dict[str, t.Any] expected_behavior: str # "sets_hook", "runs_immediately", "appends", "global" min_version: str = "3.2" SET_HOOK_FLAG_TEST_CASES: list[SetHookFlagTestCase] = [ SetHookFlagTestCase( "append_to_existing", {"append": True}, "appends", ), SetHookFlagTestCase( "global_hook", {"global_": True}, "global", ), SetHookFlagTestCase( "run_immediately", {"run": True}, "runs_immediately", ), SetHookFlagTestCase( "append_and_global", {"append": True, "global_": True}, "appends", ), ] @pytest.mark.parametrize( "test_case", [pytest.param(tc, id=tc.test_id) for tc in SET_HOOK_FLAG_TEST_CASES], ) def test_set_hook_flag_combinations( server: Server, test_case: SetHookFlagTestCase, ) -> None: """Test set_hook with various flag combinations.""" if not has_gte_version(test_case.min_version): pytest.skip(f"Requires tmux {test_case.min_version}+") session = server.new_session(session_name="test_flags") hook_name = "session-renamed" hook_cmd = "display-message 'flag test'" if test_case.expected_behavior == "appends": # Set initial hook first session.set_hook(f"{hook_name}[0]", "display-message 'initial'") session.set_hook(hook_name, hook_cmd, **test_case.flag_kwargs) # Verify append added another entry if test_case.flag_kwargs.get("global_"): # Use raw command for global hooks result = server.cmd("show-hooks", "-g", hook_name) assert result.stdout is not None parsed = Hooks.from_stdout(result.stdout) else: hooks = session._show_hook(hook_name) assert hooks is not None parsed = Hooks.from_stdout(hooks) hook_values = parsed.session_renamed.as_list() assert len(hook_values) >= 1 elif test_case.expected_behavior == "global": session.set_hook(f"{hook_name}[0]", hook_cmd, **test_case.flag_kwargs) # Global hook should be visible from server with -g flag result = server.cmd("show-hooks", "-g", f"{hook_name}[0]") assert result.stdout is not None assert len(result.stdout) > 0 assert "display-message" in result.stdout[0] elif test_case.expected_behavior == "runs_immediately": # The -R flag runs hook immediately WITHOUT storing # So after set_hook with run=True, hook should NOT be stored session.set_hook(hook_name, hook_cmd, **test_case.flag_kwargs) # Hook should NOT be stored (run immediately and discarded) hooks = session._show_hook(hook_name) # Either None or empty if hooks: parsed = Hooks.from_stdout(hooks) # May be empty or have default empty entry assert parsed.session_renamed is None or len(parsed.session_renamed) == 0 # Cleanup session.unset_hook(hook_name) if test_case.flag_kwargs.get("global_"): server.cmd("set-hook", "-gu", hook_name) # ============================================================================= # Hook Scope Tests # ============================================================================= class HookScopeTestCase(t.NamedTuple): """Test case for hook scope handling.""" test_id: str scope: str # "session", "window", "pane" scope_flag: str # tmux flag for show-hooks min_version: str = "3.2" HOOK_SCOPE_TEST_CASES: list[HookScopeTestCase] = [ HookScopeTestCase("session_scope", "session", ""), HookScopeTestCase("window_scope", "window", "-w", "3.2"), HookScopeTestCase("pane_scope", "pane", "-p", "3.2"), ] @pytest.mark.parametrize( "test_case", [pytest.param(tc, id=tc.test_id) for tc in HOOK_SCOPE_TEST_CASES], ) def test_hook_scope_handling( server: Server, test_case: HookScopeTestCase, ) -> None: """Test hooks at different scopes (session, window, pane).""" if not has_gte_version(test_case.min_version): pytest.skip(f"Requires tmux {test_case.min_version}+") session = server.new_session(session_name="test_scope") window = session.active_window assert window is not None pane = window.active_pane assert pane is not None hook_name = "session-renamed" hook_cmd = f"display-message '{test_case.scope} scope test'" # Set hook at the appropriate scope if test_case.scope == "session": session.set_hook(f"{hook_name}[0]", hook_cmd) result = session._show_hook(f"{hook_name}[0]") elif test_case.scope == "window": window.set_hook(f"{hook_name}[0]", hook_cmd) result = window._show_hook(f"{hook_name}[0]") else: # pane pane.set_hook(f"{hook_name}[0]", hook_cmd) result = pane._show_hook(f"{hook_name}[0]") assert result is not None assert len(result) > 0 assert "display-message" in result[0] # Cleanup if test_case.scope == "session": session.unset_hook(hook_name) elif test_case.scope == "window": window.unset_hook(hook_name) else: pane.unset_hook(hook_name) # ============================================================================= # show_hooks Parsing Edge Cases # ============================================================================= class ShowHooksParseTestCase(t.NamedTuple): """Test case for show_hooks output parsing edge cases.""" test_id: str setup_commands: list[tuple[str, str]] # List of (hook[idx], value) to set expected_keys: list[str] # Expected keys in result check_values: bool = True # Whether to verify specific values SHOW_HOOKS_PARSE_TEST_CASES: list[ShowHooksParseTestCase] = [ ShowHooksParseTestCase( "normal_hook_value", [("session-renamed[0]", "display-message 'test'")], ["session-renamed[0]"], ), ShowHooksParseTestCase( "multiple_indexed_hooks", [ ("session-renamed[0]", "display-message 'first'"), ("session-renamed[1]", "display-message 'second'"), ("session-renamed[5]", "display-message 'fifth'"), ], ["session-renamed[0]", "session-renamed[1]", "session-renamed[5]"], ), ShowHooksParseTestCase( "multiple_different_hooks", [ ("session-renamed[0]", "display-message 'renamed'"), ("after-split-window[0]", "display-message 'split'"), ], ["session-renamed[0]", "after-split-window[0]"], ), ] @pytest.mark.parametrize( "test_case", [pytest.param(tc, id=tc.test_id) for tc in SHOW_HOOKS_PARSE_TEST_CASES], ) def test_show_hooks_parsing_edge_cases( server: Server, test_case: ShowHooksParseTestCase, ) -> None: """Test show_hooks parses various output formats correctly.""" session = server.new_session(session_name="test_parsing") # Setup hooks for hook, value in test_case.setup_commands: session.set_hook(hook, value) # Get all hooks via show_hooks hooks = session.show_hooks() # Verify expected keys are present for key in test_case.expected_keys: assert key in hooks, f"Expected key {key} not found in {list(hooks.keys())}" if test_case.check_values: for key in test_case.expected_keys: assert hooks[key] is not None, f"Expected value for {key} to be non-None" # Cleanup for hook, _ in test_case.setup_commands: base_hook = hook.split("[")[0] session.unset_hook(base_hook) def test_show_hooks_empty_result(server: Server) -> None: """Test show_hooks returns empty dict when no hooks are set.""" session = server.new_session(session_name="test_empty_hooks") # Fresh session should have no session-level hooks hooks = session.show_hooks() # Should be a dict (possibly empty) assert isinstance(hooks, dict)