feat(pytest): Add TempServer fixture for test server management

Adds a new pytest fixture TempServer that returns a factory for creating
tmux servers with unique socket names. Each server is automatically cleaned
up when the test completes.

The fixture provides:
- Factory function returning partial'd Server instances
- Unique socket names for each server instance
- Automatic cleanup through pytest's addfinalizer
- Support for custom tmux configs in tests

Example usage:

def test_example(TempServer):
    Server = TempServer() # Get partial'd Server
    server = Server() # Create server instance
    server.new_session()

Author: tony

src/libtmux/pytest_plugin.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import contextlib
+import functools
 import getpass
 import logging
 import os
@@ -256,3 +257,58 @@ def session(
     assert TEST_SESSION_NAME != "tmuxp"
 
     return session
+
+
+@pytest.fixture
+def TempServer(
+    request: pytest.FixtureRequest,
+) -> Server:
+    """Create a temporary tmux server that cleans up after itself.
+
+    This is similar to the server pytest fixture, but can be used outside of pytest.
+    The server will be killed when the test completes.
+
+    Returns
+    -------
+    Server
+        A factory function that returns a Server with a unique socket_name
+
+    Examples
+    --------
+    >>> server = Server()  # Create server instance
+    >>> server.new_session()
+    Session($... ...)
+    >>> server.is_alive()
+    True
+    >>> # Each call creates a new server with unique socket
+    >>> server2 = Server()
+    >>> server2.socket_name != server.socket_name
+    True
+    """
+    created_sockets: list[str] = []
+
+    def on_init(server: Server) -> None:
+        """Track created servers for cleanup."""
+        created_sockets.append(server.socket_name or "default")
+
+    def socket_name_factory() -> str:
+        """Generate unique socket names."""
+        return f"libtmux_test{next(namer)}"
+
+    def fin() -> None:
+        """Kill all servers created with these sockets."""
+        for socket_name in created_sockets:
+            server = Server(socket_name=socket_name)
+            if server.is_alive():
+                server.kill()
+
+    request.addfinalizer(fin)
+
+    return t.cast(
+        "Server",
+        functools.partial(
+            Server,
+            on_init=on_init,
+            socket_name_factory=socket_name_factory,
+        ),
+    )

tests/test_pytest_plugin.py

@@ -3,11 +3,16 @@
 from __future__ import annotations
 
 import textwrap
+import time
 import typing as t
 
 if t.TYPE_CHECKING:
+    import pathlib
+
     import pytest
 
+    from libtmux.server import Server
+
 
 def test_plugin(
     pytester: pytest.Pytester,
@@ -71,3 +76,83 @@ def test_repo_git_remote_checkout(
     # Test
     result = pytester.runpytest(str(first_test_filename))
     result.assert_outcomes(passed=1)
+
+
+def test_temp_server(TempServer: t.Callable[..., Server]) -> None:
+    """Test TempServer creates and cleans up server."""
+    server = TempServer()
+    assert server.is_alive() is False  # Server not started yet
+
+    session = server.new_session()
+    assert server.is_alive() is True
+    assert len(server.sessions) == 1
+    assert session.session_name is not None
+
+    # Test socket name is unique
+    assert server.socket_name is not None
+    assert server.socket_name.startswith("libtmux_test")
+
+    # Each call creates a new server with unique socket
+    server2 = TempServer()
+    assert server2.socket_name is not None
+    assert server2.socket_name.startswith("libtmux_test")
+    assert server2.socket_name != server.socket_name
+
+
+def test_temp_server_with_config(
+    TempServer: t.Callable[..., Server],
+    tmp_path: pathlib.Path,
+) -> None:
+    """Test TempServer with config file."""
+    config_file = tmp_path / "tmux.conf"
+    config_file.write_text("set -g status off", encoding="utf-8")
+
+    server = TempServer(config_file=str(config_file))
+    session = server.new_session()
+
+    # Verify config was loaded
+    assert session.cmd("show-options", "-g", "status").stdout[0] == "status off"
+
+
+def test_temp_server_cleanup(TempServer: t.Callable[..., Server]) -> None:
+    """Test TempServer properly cleans up after itself."""
+    server = TempServer()
+    socket_name = server.socket_name
+    assert socket_name is not None
+
+    # Create multiple sessions
+    server.new_session(session_name="test1")
+    server.new_session(session_name="test2")
+    assert len(server.sessions) == 2
+
+    # Verify server is alive
+    assert server.is_alive() is True
+
+    # Delete server and verify cleanup
+    server.kill()
+    time.sleep(0.1)  # Give time for cleanup
+
+    # Create new server to verify old one was cleaned up
+    new_server = TempServer()
+    assert new_server.is_alive() is False  # Server not started yet
+    new_server.new_session()  # This should work if old server was cleaned up
+    assert new_server.is_alive() is True
+
+
+def test_temp_server_multiple(TempServer: t.Callable[..., Server]) -> None:
+    """Test multiple TempServer instances can coexist."""
+    server1 = TempServer()
+    server2 = TempServer()
+
+    # Each server should have a unique socket
+    assert server1.socket_name != server2.socket_name
+
+    # Create sessions in each server
+    server1.new_session(session_name="test1")
+    server2.new_session(session_name="test2")
+
+    # Verify sessions are in correct servers
+    assert any(s.session_name == "test1" for s in server1.sessions)
+    assert any(s.session_name == "test2" for s in server2.sessions)
+    assert not any(s.session_name == "test1" for s in server2.sessions)
+    assert not any(s.session_name == "test2" for s in server1.sessions)