tests: extract code examples from docs/pytest-plugin into real tests

Author: tony

tests/pytest_examples/test_complex_layouts.py

@@ -0,0 +1,74 @@
+"""Examples of testing with complex window layouts."""
+
+from __future__ import annotations
+
+import time
+
+from libtmux.constants import PaneDirection
+
+
+def test_complex_layouts(session) -> None:
+    """Test creating and interacting with complex window layouts."""
+    # Create a window with multiple panes in a specific layout
+    window = session.new_window(window_name="complex-layout")
+
+    # Start with a simple pane
+    main_pane = window.active_pane
+
+    # Split into a left pane and right column
+    left_pane = main_pane
+    right_top = window.split(direction=PaneDirection.Right, percent=50)
+
+    # Split the right column into top and bottom
+    right_bottom = right_top.split(direction=PaneDirection.Below, percent=50)
+
+    # Apply a layout
+    window.select_layout("main-vertical")
+
+    # Verify the layout was applied
+    current_layout = window.get("window_layout")
+    assert current_layout is not None, "Layout was not set"
+
+    # Send unique commands to each pane for identification
+    left_pane.send_keys("echo 'Left Pane'", enter=True)
+    right_top.send_keys("echo 'Right Top'", enter=True)
+    right_bottom.send_keys("echo 'Right Bottom'", enter=True)
+
+    time.sleep(0.5)
+
+    # Verify each pane has the correct content
+    assert any("Left Pane" in line for line in left_pane.capture_pane())
+    assert any("Right Top" in line for line in right_top.capture_pane())
+    assert any("Right Bottom" in line for line in right_bottom.capture_pane())
+
+
+def test_tiled_layout(session) -> None:
+    """Test the tiled layout with multiple panes."""
+    window = session.new_window(window_name="tiled-layout")
+
+    # Create multiple panes
+    pane1 = window.active_pane
+    pane2 = window.split(direction=PaneDirection.Right)
+    pane3 = pane1.split(direction=PaneDirection.Below)
+    pane4 = pane2.split(direction=PaneDirection.Below)
+
+    # Apply the tiled layout
+    window.select_layout("tiled")
+
+    # Verify the layout was applied
+    current_layout = window.get("window_layout")
+    assert current_layout is not None, "Layout was not set"
+
+    # Send unique commands to each pane
+    pane1.send_keys("echo 'Pane 1'", enter=True)
+    pane2.send_keys("echo 'Pane 2'", enter=True)
+    pane3.send_keys("echo 'Pane 3'", enter=True)
+    pane4.send_keys("echo 'Pane 4'", enter=True)
+
+    time.sleep(0.5)
+
+    # Verify each pane has the correct content
+    assert any("Pane 1" in line for line in pane1.capture_pane())
+    assert any("Pane 2" in line for line in pane2.capture_pane())
+    assert any("Pane 3" in line for line in pane3.capture_pane())
+    assert any("Pane 4" in line for line in pane4.capture_pane())

tests/pytest_examples/test_direct_testserver.py

@@ -0,0 +1,57 @@
+"""Examples of using TestServer directly."""
+
+from __future__ import annotations
+
+import pytest
+
+from libtmux.pytest_plugin import TestServer
+
+
+@pytest.fixture
+def custom_server():
+    """Create a custom server with specific parameters."""
+    with TestServer(
+        socket_name="custom-socket",
+        config_file=None,
+        colors=256,
+        focused=True,
+    ) as server:
+        yield server
+
+
+def test_custom_server_config(custom_server) -> None:
+    """Test a server with custom configuration."""
+    # Verify server is running
+    assert custom_server.is_alive()
+
+    # Verify custom socket name
+    assert "custom-socket" in custom_server.socket_path
+
+    # Create a session
+    session = custom_server.new_session(session_name="custom-test")
+    assert session.name == "custom-test"
+
+    # Get color configuration
+    colors = session.server.show_option("default-terminal")
+    assert colors is not None
+
+
+def test_testserver_direct_usage() -> None:
+    """Test using TestServer directly as a context manager."""
+    with TestServer() as server:
+        # Create a session
+        session = server.new_session(session_name="direct-test")
+        assert session.name == "direct-test"
+
+        # Create multiple windows
+        windows = []
+        for i in range(3):
+            window = session.new_window(window_name=f"window-{i}")
+            windows.append(window)
+
+        # Verify windows were created
+        assert len(session.windows) >= 3
+        for i, window in enumerate(windows):
+            assert f"window-{i}" == window.window_name
+
+    # Server is automatically cleaned up outside the context

tests/pytest_examples/test_pane_operations.py

@@ -0,0 +1,86 @@
+"""Examples of operations with tmux panes."""
+
+from __future__ import annotations
+
+import time
+
+from libtmux.constants import PaneDirection
+
+
+def test_pane_functions(pane) -> None:
+    """Test basic pane functions."""
+    # Send a command to the pane
+    pane.send_keys("echo 'Hello from pane'", enter=True)
+
+    # Give the command time to execute
+    time.sleep(0.5)
+
+    # Capture and verify the output
+    output = pane.capture_pane()
+    assert any("Hello from pane" in line for line in output)
+
+
+def test_window_functions(window) -> None:
+    """Test basic window functions."""
+    # Get the active pane
+    pane = window.active_pane
+    assert pane is not None
+
+    # Split the window
+    window.split_window()
+    assert len(window.panes) == 2
+
+
+def test_pane_resizing(window) -> None:
+    """Test resizing panes."""
+    # Start with a single pane
+    original_pane = window.active_pane
+
+    # Split horizontally
+    second_pane = window.split(direction=PaneDirection.Right, percent=50)
+    assert len(window.panes) == 2
+
+    # Resize the first pane to be larger
+    original_pane.resize(width=60)
+    time.sleep(0.5)
+
+    # Get updated dimensions
+    dimensions1 = original_pane.dimensions
+    dimensions2 = second_pane.dimensions
+
+    # The first pane should be wider
+    assert dimensions1["width"] > dimensions2["width"]
+
+    # Now resize the second pane to be larger
+    second_pane.resize(width=60)
+    time.sleep(0.5)
+
+    # Get updated dimensions
+    dimensions1 = original_pane.dimensions
+    dimensions2 = second_pane.dimensions
+
+    # The second pane should now be wider
+    assert dimensions2["width"] > dimensions1["width"]
+
+
+def test_pane_capturing(pane) -> None:
+    """Test capturing pane content in different formats."""
+    # Send multiple lines of content
+    pane.send_keys("echo 'Line 1'", enter=True)
+    pane.send_keys("echo 'Line 2'", enter=True)
+    pane.send_keys("echo 'Line 3'", enter=True)
+    time.sleep(0.5)
+
+    # Capture as a list of lines
+    output_lines = pane.capture_pane()
+    assert isinstance(output_lines, list)
+    assert any("Line 1" in line for line in output_lines)
+    assert any("Line 2" in line for line in output_lines)
+    assert any("Line 3" in line for line in output_lines)
+
+    # Capture as a single string
+    output_str = pane.capture_pane(as_str=True)
+    assert isinstance(output_str, str)
+    assert "Line 1" in output_str
+    assert "Line 2" in output_str
+    assert "Line 3" in output_str

tests/pytest_examples/test_process_control.py

@@ -0,0 +1,83 @@
+"""Examples of controlling processes in tmux panes."""
+
+from __future__ import annotations
+
+import time
+
+
+def test_process_detection(pane) -> None:
+    """Test detecting running processes in a pane."""
+    # Start a long-running process
+    pane.send_keys("sleep 10", enter=True)
+    time.sleep(0.5)
+
+    # Get information about the running process
+    ps_output = pane.cmd("ps", "-o", "pid,command").stdout
+
+    # Verify the sleep command is running
+    assert any("sleep 10" in line for line in ps_output)
+
+    # Kill the process
+    pane.send_keys(chr(3), literal=True)  # Send Ctrl+C
+    time.sleep(0.5)
+
+    # Verify the process has stopped
+    ps_output = pane.cmd("ps", "-o", "pid,command").stdout
+    assert not any("sleep 10" in line for line in ps_output)
+
+
+def test_command_output_scrollback(pane) -> None:
+    """Test handling command output that exceeds visible pane height."""
+    # Generate a lot of output
+    pane.send_keys('for i in $(seq 1 100); do echo "Line $i"; done', enter=True)
+    time.sleep(1.0)
+
+    # Capture all the scrollback buffer
+    output = pane.capture_pane(start="-100")
+
+    # Check that we have captured a large portion of the output
+    assert len(output) > 50
+
+    # Verify the beginning and end of the captured output
+    final_lines = [line for line in output if "Line " in line]
+    if final_lines:
+        line_numbers = [
+            int(line.split("Line ")[1])
+            for line in final_lines
+            if line.split("Line ")[1].isdigit()
+        ]
+        if line_numbers:
+            assert max(line_numbers) > min(line_numbers)
+
+    # Clear the scrollback buffer
+    pane.clear()
+    time.sleep(0.5)
+
+    # Verify the buffer is now empty or only has the prompt
+    cleared_output = pane.capture_pane()
+    assert len([line for line in cleared_output if line.strip()]) <= 1
+
+
+def test_running_background_process(pane) -> None:
+    """Test running a process in the background."""
+    # Start a background process that writes to a file
+    pane.send_keys("touch /tmp/background_test.txt", enter=True)
+    pane.send_keys(
+        '(for i in $(seq 1 5); do echo "Update $i" >> /tmp/background_test.txt; sleep 1; done) &',
+        enter=True,
+    )
+    time.sleep(0.5)
+
+    # Check the file periodically
+    for _attempt in range(5):
+        pane.send_keys("cat /tmp/background_test.txt", enter=True)
+        time.sleep(1.0)
+        output = pane.capture_pane()
+        if any("Update 3" in line for line in output):
+            break
+
+    # Verify we got at least some updates
+    assert any("Update" in line for line in output)
+
+    # Clean up
+    pane.send_keys("rm /tmp/background_test.txt", enter=True)

tests/pytest_examples/test_server_restart.py

@@ -0,0 +1,42 @@
+"""Examples of testing across tmux server restarts."""
+
+from __future__ import annotations
+
+import time
+
+import libtmux
+
+
+def test_persist_across_restart(session) -> None:
+    """Test functionality across server restarts."""
+    # Set up initial state
+    window = session.new_window(window_name="persist-test")
+    pane = window.active_pane
+    pane.send_keys("echo 'Data to persist' > /tmp/test-data.txt", enter=True)
+    time.sleep(0.5)
+
+    # Get server info for reconnecting
+    socket_path = session.server.socket_path
+    session_id = session.id
+
+    # Kill the server
+    session.server.kill_server()
+
+    # Create a new server with the same socket
+    new_server = libtmux.Server(socket_path=socket_path)
+    new_server.new_session(session_name="restart-test")
+
+    # Verify data persisted
+    new_session = new_server.get_by_id(session_id)
+    assert new_session is None  # Old session should not exist
+
+    # But our file should still exist
+    new_pane = new_server.sessions[0].attached_window.active_pane
+    new_pane.send_keys("cat /tmp/test-data.txt", enter=True)
+    time.sleep(0.5)
+
+    output = new_pane.capture_pane()
+    assert any("Data to persist" in line for line in output)
+
+    # Clean up
+    new_pane.send_keys("rm /tmp/test-data.txt", enter=True)