Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-libtmux for openSUSE:Factory checked in at 2025-02-18 19:12:43 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-libtmux (Old) and /work/SRC/openSUSE:Factory/.python-libtmux.new.8181 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-libtmux" Tue Feb 18 19:12:43 2025 rev:15 rq:1246648 version:0.44.2 Changes: -------- --- /work/SRC/openSUSE:Factory/python-libtmux/python-libtmux.changes 2025-02-17 20:57:14.067248199 +0100 +++ /work/SRC/openSUSE:Factory/.python-libtmux.new.8181/python-libtmux.changes 2025-02-18 19:13:45.216161253 +0100 @@ -1,0 +2,12 @@ +Tue Feb 18 06:01:52 UTC 2025 - Johannes Kastl <[email protected]> + +- update to 0.44.2: + * Bug fixes + - fix(typings) Move typing-extensions into TypeGuard by @tony + in #572 + * Documentation + - Doc / typos fixes by @tony in #569 + * Development + - Tests: Improved parametrization by @tony in #570 + +------------------------------------------------------------------- Old: ---- libtmux-0.44.1.tar.gz New: ---- libtmux-0.44.2.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-libtmux.spec ++++++ --- /var/tmp/diff_new_pack.ftEy5J/_old 2025-02-18 19:13:45.652179504 +0100 +++ /var/tmp/diff_new_pack.ftEy5J/_new 2025-02-18 19:13:45.656179671 +0100 @@ -18,7 +18,7 @@ %{?sle15_python_module_pythons} Name: python-libtmux -Version: 0.44.1 +Version: 0.44.2 Release: 0 Summary: Python API / wrapper for tmux License: MIT ++++++ libtmux-0.44.1.tar.gz -> libtmux-0.44.2.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/CHANGES new/libtmux-0.44.2/CHANGES --- old/libtmux-0.44.1/CHANGES 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/CHANGES 2025-02-17 17:34:54.000000000 +0100 @@ -15,6 +15,21 @@ - _Future release notes will be placed here_ +## libtmux 0.44.2 (2025-02-17) + +### Bug fix + +- Fix `typing_extensions` issue by wrapping it in `TYPE_CHECKING`, continuation of #564, via #572. + +### Development + +- Improved test organization and coverage in `test_common.py` (#570): + - Consolidated version-related tests into parametrized fixtures using NamedTuples + - Added comprehensive test cases for various version formats (master, next, OpenBSD, dev, rc) + - Improved test readability with clear test IDs and logical grouping + - Consistent use of pytest parametrize convention across test suite +- Fix broken test for `test_window_rename` (#570) + ## libtmux 0.44.1 (2025-02-17) ### Packaging diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/docs/about.md new/libtmux-0.44.2/docs/about.md --- old/libtmux-0.44.1/docs/about.md 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/docs/about.md 2025-02-17 17:34:54.000000000 +0100 @@ -17,7 +17,7 @@ libtmux is a [typed](https://docs.python.org/3/library/typing.html) [abstraction layer] for tmux. It builds upon the concept of targets `-t`, to direct commands against -individual session, windows and panes and `FORMATS`, template variables +individual sessions, windows and panes and `FORMATS`, template variables exposed by tmux to describe their properties. Think of `-t` analogously to [scope]. @@ -32,18 +32,18 @@ | {class}`Window` | {class}`Pane` | {class}`Session` | | {class}`Pane` | None | {class}`Window` | -Internally, tmux allows multiple servers to be ran on a system. Each one +Internally, tmux allows multiple servers to be run on a system. Each one uses a socket. The server-client architecture is executed so cleanly, many users don't think about it. tmux automatically connects to a default socket name and location for you if none (`-L`, `-S`) is specified. A server will be created automatically upon starting if none exists. -A server can have multiple sessions. `Ctrl-a s` can be used to switch +A server can have multiple sessions. `Ctrl+a s` can be used to switch between sessions running on the server. -Sessions, Windows and Panes all have their own unique identifier for +Sessions, windows and panes all have their own unique identifier for internal purposes. {class}`common.TmuxMappingObject` will make use of the -unique identifiers (`session_id`, `window_id`, `pane_id` ) to look +unique identifiers (`session_id`, `window_id`, `pane_id`) to look up the data stored in the {class}`Server` object. | Object | Prefix | Example | @@ -56,7 +56,7 @@ ## Similarities to tmux and Pythonics libtmux was built in the spirit of understanding how tmux operates -and how python objects and tools can abstract the API's in a pleasant way. +and how python objects and tools can abstract the APIs in a pleasant way. libtmux uses `FORMATTERS` in tmux to give identity attributes to {class}`Session`, {class}`Window` and {class}`Pane` objects. See @@ -66,13 +66,13 @@ How is libtmux able to keep references to panes, windows and sessions? -> Tmux has unique ID's for sessions, windows and panes. +> Tmux has unique IDs for sessions, windows and panes. > > panes use `%`, such as `%1234` > > windows use `@`, such as `@2345` > -> sessions use `$`, for money, such as `$` +> sessions use `$`, such as `$13` > > How is libtmux able to handle windows with no names? @@ -82,7 +82,7 @@ > Pane index refers to the order of a pane on the screen. > -> Window index refers to the # of the window in the session. +> Window index refers to the number of the window in the session. > > To assert pane, window and session data, libtmux will use > {meth}`Server.sessions()`, {meth}`Session.windows()`, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/docs/developing.md new/libtmux-0.44.2/docs/developing.md --- old/libtmux-0.44.1/docs/developing.md 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/docs/developing.md 2025-02-17 17:34:54.000000000 +0100 @@ -1,6 +1,6 @@ # Development -Install and [git] and [uv] +Install [git] and [uv] Clone: @@ -20,15 +20,29 @@ [installation documentation]: https://docs.astral.sh/uv/getting-started/installation/ [git]: https://git-scm.com/ +[uv]: https://github.com/astral-sh/uv Makefile commands prefixed with `watch_` will watch files and rerun. ## Tests -`uv run py.test` +```console +$ uv run py.test +``` -Helpers: `make test` -Rerun tests on file change: `make watch_test` (requires [entr(1)]) +### Helpers + +```console +$ make test +``` + +Rerun tests on file change: + +```console +$ make watch_test +``` + +(requires [entr(1)]) ### Pytest plugin @@ -44,19 +58,50 @@ [sphinx-autobuild] will automatically build the docs, watch for file changes and launch a server. -From home directory: `make start_docs` From inside `docs/`: `make start` +From home directory: +```console +$ make start_docs +``` + +From inside `docs/`: +```console +$ make start +``` [sphinx-autobuild]: https://github.com/executablebooks/sphinx-autobuild ### Manual documentation (the hard way) -`cd docs/` and `make html` to build. `make serve` to start http server. +```console +$ cd docs/ +$ make html +``` + +to build. -Helpers: `make build_docs`, `make serve_docs` +```console +$ make serve +``` -Rebuild docs on file change: `make watch_docs` (requires [entr(1)]) +to start http server. -Rebuild docs and run server via one terminal: `make dev_docs` (requires above, and a `make(1)` with +Helpers: +```console +$ make build_docs +$ make serve_docs +``` + +Rebuild docs on file change: +```console +$ make watch_docs +``` +(requires [entr(1)]) + +Rebuild docs and run server via one terminal: +```console +$ make dev_docs +``` +(requires above, and {command}`make(1)` with `-J` support, e.g. GNU Make) ## Linting @@ -95,7 +140,7 @@ $ make watch_ruff ``` -requires [`entr(1)`]. +requires [entr(1)]. ```` @@ -177,7 +222,7 @@ $ make watch_mypy ``` -requires [`entr(1)`]. +requires [entr(1)]. ```` ## Releasing @@ -197,15 +242,17 @@ `CHANGES`: Assure any PRs merged since last release are mentioned. Give a thank you to the contributor. Set the header with the new version and the date. Leave the "current" header and _Insert changes/features/fixes for next release here_ at -the top:: +the top: + +``` +current +------- +- *Insert changes/features/fixes for next release here* - current - ------- - - *Insert changes/features/fixes for next release here* - - libtmux 0.9.1 (2020-10-12) - -------------------------- - - :issue:`1`: Fix bug +libtmux 0.9.1 (2020-10-12) +-------------------------- +- :issue:`1`: Fix bug +``` `libtmux/__init__.py` and `__about__.py` - Set version @@ -225,20 +272,21 @@ This isn't used yet since package maintainers may want setup.py in the source. See https://github.com/tmux-python/tmuxp/issues/625. -As of 0.10, [uv] handles virtualenv creation, package requirements, versioning, +As of v0.10, [uv] handles virtualenv creation, package requirements, versioning, building, and publishing. Therefore there is no setup.py or requirements files. -Update `__version__` in `__about__.py` and `pyproject.toml`:: +Update `__version__` in `__about__.py` and `pyproject.toml`: - git commit -m 'build(libtmux): Tag v0.1.1' - git tag v0.1.1 - git push - git push --tags +```console +git commit -m 'build(libtmux): Tag v0.1.1' +git tag v0.1.1 +git push +git push --tags +``` [twine]: https://twine.readthedocs.io/ [uv]: https://github.com/astral-sh/uv [entr(1)]: http://eradman.com/entrproject/ -[`entr(1)`]: http://eradman.com/entrproject/ [ruff format]: https://docs.astral.sh/ruff/formatter/ [ruff]: https://ruff.rs [mypy]: http://mypy-lang.org/ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/docs/pytest-plugin/index.md new/libtmux-0.44.2/docs/pytest-plugin/index.md --- old/libtmux-0.44.1/docs/pytest-plugin/index.md 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/docs/pytest-plugin/index.md 2025-02-17 17:34:54.000000000 +0100 @@ -33,7 +33,7 @@ View libtmux's own [tests/](https://github.com/tmux-python/libtmux/tree/master/tests) as well as tmuxp's [tests/](https://github.com/tmux-python/tmuxp/tree/master/tests). -libtmux's tests `autouse` the {ref}`recommended-fixtures` above to ensure stable, assertions and +libtmux's tests `autouse` the {ref}`recommended-fixtures` above to ensure stable test execution, assertions and object lookups in the test grid. ## pytest-tmux @@ -41,14 +41,14 @@ `pytest-tmux` works through providing {ref}`pytest fixtures <pytest:fixtures-api>` - so read up on those! -The plugin's fixtures guarantee a fresh, headless `tmux(1)` server, session, window, or pane is +The plugin's fixtures guarantee a fresh, headless {command}`tmux(1)` server, session, window, or pane is passed into your test. (recommended-fixtures)= ## Recommended fixtures -These are fixtures are automatically used when the plugin is enabled and `pytest` is run. +These fixtures are automatically used when the plugin is enabled and `pytest` is run. - Creating temporary, test directories for: - `/home/` ({func}`home_path`) @@ -67,14 +67,14 @@ - Pass a `config_file` into {class}`~libtmux.Server` - Set the `HOME` directory to a local or temporary pytest path with a configuration file -You could also read the code and override {func}`server fixtures <libtmux.pytest_plugin.server>`'s in your own doctest. doctest. +You could also read the code and override {func}`server fixture <libtmux.pytest_plugin.server>` in your own doctest. (custom_session_params)= ### Custom session parameters -You can override `session_params` to custom the `session` fixture. The -dictionary will directly pass into :meth:`Server.new_session` keyword arguments. +You can override `session_params` to customize the `session` fixture. The +dictionary will directly pass into {meth}`Server.new_session` keyword arguments. ```python import pytest diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/docs/quickstart.md new/libtmux-0.44.2/docs/quickstart.md --- old/libtmux-0.44.1/docs/quickstart.md 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/docs/quickstart.md 2025-02-17 17:34:54.000000000 +0100 @@ -50,15 +50,14 @@ ``` [pip]: https://pip.pypa.io/en/stable/ +[ptpython]: https://github.com/prompt-toolkit/ptpython ## Start a tmux session Now, let's open a tmux session. ```console - $ tmux new-session -n bar -s foo - ``` This tutorial will be using the session and window name in the example. @@ -177,7 +176,7 @@ However, this isn't guaranteed, libtmux works against current tmux information, the session's name could be changed, or another tmux session may be created, -so {meth}`Server.sessions` and {meth}`Server.windows` exists as a lookup. +so {meth}`Server.sessions` and {meth}`Server.windows` exist as a lookup. ## Get session by ID diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/pyproject.toml new/libtmux-0.44.2/pyproject.toml --- old/libtmux-0.44.1/pyproject.toml 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/pyproject.toml 2025-02-17 17:34:54.000000000 +0100 @@ -1,6 +1,6 @@ [project] name = "libtmux" -version = "0.44.1" +version = "0.44.2" description = "Typed library that provides an ORM wrapper for tmux, a terminal multiplexer." requires-python = ">=3.9,<4.0" authors = [ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/src/libtmux/__about__.py new/libtmux-0.44.2/src/libtmux/__about__.py --- old/libtmux-0.44.1/src/libtmux/__about__.py 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/src/libtmux/__about__.py 2025-02-17 17:34:54.000000000 +0100 @@ -4,7 +4,7 @@ __title__ = "libtmux" __package_name__ = "libtmux" -__version__ = "0.44.1" +__version__ = "0.44.2" __description__ = "Typed scripting library / ORM / API wrapper for tmux" __email__ = "[email protected]" __author__ = "Tony Narlock" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/src/libtmux/pane.py new/libtmux-0.44.2/src/libtmux/pane.py --- old/libtmux-0.44.1/src/libtmux/pane.py 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/src/libtmux/pane.py 2025-02-17 17:34:54.000000000 +0100 @@ -13,8 +13,6 @@ import typing as t import warnings -from typing_extensions import Self - from libtmux.common import has_gte_version, has_lt_version, tmux_cmd from libtmux.constants import ( PANE_DIRECTION_FLAG_MAP, @@ -28,12 +26,17 @@ from . import exc if t.TYPE_CHECKING: + import sys import types from .server import Server from .session import Session from .window import Window + if sys.version_info >= (3, 11): + from typing import Self + else: + from typing_extensions import Self logger = logging.getLogger(__name__) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/src/libtmux/server.py new/libtmux-0.44.2/src/libtmux/server.py --- old/libtmux-0.44.1/src/libtmux/server.py 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/src/libtmux/server.py 2025-02-17 17:34:54.000000000 +0100 @@ -15,8 +15,6 @@ import typing as t import warnings -from typing_extensions import Self - from libtmux._internal.query_list import QueryList from libtmux.common import tmux_cmd from libtmux.neo import fetch_objs @@ -39,9 +37,9 @@ import types if sys.version_info >= (3, 10): - from typing import TypeAlias + from typing import Self, TypeAlias else: - from typing_extensions import TypeAlias + from typing_extensions import Self, TypeAlias DashLiteral: TypeAlias = t.Literal["-"] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/src/libtmux/session.py new/libtmux-0.44.2/src/libtmux/session.py --- old/libtmux-0.44.1/src/libtmux/session.py 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/src/libtmux/session.py 2025-02-17 17:34:54.000000000 +0100 @@ -13,8 +13,6 @@ import typing as t import warnings -from typing_extensions import Self - from libtmux._internal.query_list import QueryList from libtmux.constants import WINDOW_DIRECTION_FLAG_MAP, WindowDirection from libtmux.formats import FORMAT_SEPARATOR @@ -33,10 +31,16 @@ ) if t.TYPE_CHECKING: + import sys import types from libtmux.common import tmux_cmd + if sys.version_info >= (3, 11): + from typing import Self + else: + from typing_extensions import Self + from .server import Server diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/src/libtmux/window.py new/libtmux-0.44.2/src/libtmux/window.py --- old/libtmux-0.44.1/src/libtmux/window.py 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/src/libtmux/window.py 2025-02-17 17:34:54.000000000 +0100 @@ -13,8 +13,6 @@ import typing as t import warnings -from typing_extensions import Self - from libtmux._internal.query_list import QueryList from libtmux.common import has_gte_version, tmux_cmd from libtmux.constants import ( @@ -30,11 +28,18 @@ from .common import PaneDict, WindowOptionDict, handle_option_error if t.TYPE_CHECKING: + import sys import types from .server import Server from .session import Session + if sys.version_info >= (3, 11): + from typing import Self + else: + from typing_extensions import Self + + logger = logging.getLogger(__name__) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/tests/test_common.py new/libtmux-0.44.2/tests/test_common.py --- old/libtmux-0.44.1/tests/test_common.py 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/tests/test_common.py 2025-02-17 17:34:54.000000000 +0100 @@ -32,162 +32,11 @@ version_regex = re.compile(r"([0-9]\.[0-9])|(master)") -def test_allows_master_version(monkeypatch: pytest.MonkeyPatch) -> None: - """Assert get_version() works with builds from git trunk.""" - - class Hi: - stdout: t.ClassVar = ["tmux master"] - stderr = None - - def mock_tmux_cmd(*args: t.Any, **kwargs: t.Any) -> Hi: - return Hi() - - monkeypatch.setattr(libtmux.common, "tmux_cmd", mock_tmux_cmd) - - assert has_minimum_version() - assert has_gte_version(TMUX_MIN_VERSION) - assert has_gt_version(TMUX_MAX_VERSION), "Greater than the max-supported version" - assert get_version() == f"{TMUX_MAX_VERSION}-master", ( - "Is the latest supported version with -master appended" - ) - - -def test_allows_next_version(monkeypatch: pytest.MonkeyPatch) -> None: - """Assert get_version() supports next version.""" - TMUX_NEXT_VERSION = str(float(TMUX_MAX_VERSION) + 0.1) - - class Hi: - stdout: t.ClassVar = [f"tmux next-{TMUX_NEXT_VERSION}"] - stderr = None - - def mock_tmux_cmd(*args: t.Any, **kwargs: t.Any) -> Hi: - return Hi() - - monkeypatch.setattr(libtmux.common, "tmux_cmd", mock_tmux_cmd) - - assert has_minimum_version() - assert has_gte_version(TMUX_MIN_VERSION) - assert has_gt_version(TMUX_MAX_VERSION), "Greater than the max-supported version" - assert get_version() == TMUX_NEXT_VERSION - - -def test_get_version_openbsd(monkeypatch: pytest.MonkeyPatch) -> None: - """Assert get_version() with OpenBSD versions.""" - - class Hi: - stderr: t.ClassVar = ["tmux: unknown option -- V"] - - def mock_tmux_cmd(*args: t.Any, **kwargs: t.Any) -> Hi: - return Hi() - - monkeypatch.setattr(libtmux.common, "tmux_cmd", mock_tmux_cmd) - monkeypatch.setattr(sys, "platform", "openbsd 5.2") - assert has_minimum_version() - assert has_gte_version(TMUX_MIN_VERSION) - assert has_gt_version(TMUX_MAX_VERSION), "Greater than the max-supported version" - assert get_version() == f"{TMUX_MAX_VERSION}-openbsd", ( - "Is the latest supported version with -openbsd appended" - ) - - -def test_get_version_too_low(monkeypatch: pytest.MonkeyPatch) -> None: - """Assert get_version() raises if tmux version too low.""" - - class Hi: - stderr: t.ClassVar = ["tmux: unknown option -- V"] - - def mock_tmux_cmd(*args: t.Any, **kwargs: t.Any) -> Hi: - return Hi() - - monkeypatch.setattr(libtmux.common, "tmux_cmd", mock_tmux_cmd) - with pytest.raises(LibTmuxException) as exc_info: - get_version() - exc_info.match("is running tmux 1.3 or earlier") - - -def test_ignores_letter_versions(monkeypatch: pytest.MonkeyPatch) -> None: - """Tests version utilities ignores letters such as 1.8b. - - See ticket https://github.com/tmux-python/tmuxp/issues/55. - - In version 0.1.7 this is adjusted to use LooseVersion, in order to - allow letters. - - """ - monkeypatch.setattr(libtmux.common, "TMUX_MIN_VERSION", "1.9a") - result = has_minimum_version() - assert result - - monkeypatch.setattr(libtmux.common, "TMUX_MIN_VERSION", "1.8a") - result = has_minimum_version() - assert result - - # Should not throw - assert isinstance(has_version("1.8"), bool) - assert isinstance(has_version("1.8a"), bool) - assert isinstance(has_version("1.9a"), bool) - - -def test_error_version_less_1_7(monkeypatch: pytest.MonkeyPatch) -> None: - """Test raises if tmux version less than 1.7.""" - - def mock_get_version() -> LooseVersion: - return LooseVersion("1.7") - - monkeypatch.setattr(libtmux.common, "get_version", mock_get_version) - with pytest.raises(LibTmuxException) as excinfo: - has_minimum_version() - excinfo.match(r"libtmux only supports") - - with pytest.raises(LibTmuxException) as excinfo: - has_minimum_version() - - excinfo.match(r"libtmux only supports") - - def test_has_version() -> None: """Test has_version().""" assert has_version(str(get_version())) -def test_has_gt_version() -> None: - """Test has_gt_version().""" - assert has_gt_version("1.6") - assert has_gt_version("1.6b") - - assert not has_gt_version("4.0") - assert not has_gt_version("4.0b") - - -def test_has_gte_version() -> None: - """Test has_gte_version().""" - assert has_gte_version("1.6") - assert has_gte_version("1.6b") - assert has_gte_version(str(get_version())) - - assert not has_gte_version("4.0") - assert not has_gte_version("4.0b") - - -def test_has_lt_version() -> None: - """Test has_lt_version().""" - assert has_lt_version("4.0a") - assert has_lt_version("4.0") - - assert not has_lt_version("1.7") - assert not has_lt_version(str(get_version())) - - -def test_has_lte_version() -> None: - """Test has_lti_version().""" - assert has_lte_version("4.0a") - assert has_lte_version("4.0") - assert has_lte_version(str(get_version())) - - assert not has_lte_version("1.7") - assert not has_lte_version("1.7b") - - def test_tmux_cmd_raises_on_not_found(monkeypatch: pytest.MonkeyPatch) -> None: """Verify raises if tmux command not found.""" monkeypatch.setenv("PATH", "") @@ -203,23 +52,59 @@ class SessionCheckName(t.NamedTuple): """Test fixture for test_session_check_name().""" + test_id: str session_name: str | None raises: bool exc_msg_regex: str | None +SESSION_CHECK_NAME_FIXTURES: list[SessionCheckName] = [ + SessionCheckName( + test_id="empty_string", + session_name="", + raises=True, + exc_msg_regex="empty", + ), + SessionCheckName( + test_id="none_value", + session_name=None, + raises=True, + exc_msg_regex="empty", + ), + SessionCheckName( + test_id="contains_period", + session_name="my great session.", + raises=True, + exc_msg_regex="contains periods", + ), + SessionCheckName( + test_id="contains_colon", + session_name="name: great session", + raises=True, + exc_msg_regex="contains colons", + ), + SessionCheckName( + test_id="valid_name", + session_name="new great session", + raises=False, + exc_msg_regex=None, + ), + SessionCheckName( + test_id="valid_with_special_chars", + session_name="ajf8a3fa83fads,,,a", + raises=False, + exc_msg_regex=None, + ), +] + + @pytest.mark.parametrize( - SessionCheckName._fields, - [ - SessionCheckName("", True, "empty"), - SessionCheckName(None, True, "empty"), - SessionCheckName("my great session.", True, "contains periods"), - SessionCheckName("name: great session", True, "contains colons"), - SessionCheckName("new great session", False, None), - SessionCheckName("ajf8a3fa83fads,,,a", False, None), - ], + list(SessionCheckName._fields), + SESSION_CHECK_NAME_FIXTURES, + ids=[test.test_id for test in SESSION_CHECK_NAME_FIXTURES], ) def test_session_check_name( + test_id: str, session_name: str | None, raises: bool, exc_msg_regex: str | None, @@ -241,3 +126,385 @@ version = get_libtmux_version() assert isinstance(version, LooseVersion) assert LooseVersion(__version__) == version + + +class VersionComparisonFixture(t.NamedTuple): + """Test fixture for version comparison functions.""" + + test_id: str + version: str + comparison_type: t.Literal["gt", "gte", "lt", "lte"] + expected: bool + + +VERSION_COMPARISON_FIXTURES: list[VersionComparisonFixture] = [ + # Greater than tests + VersionComparisonFixture( + test_id="gt_older_version", + version="1.6", + comparison_type="gt", + expected=True, + ), + VersionComparisonFixture( + test_id="gt_older_version_with_letter", + version="1.6b", + comparison_type="gt", + expected=True, + ), + VersionComparisonFixture( + test_id="gt_newer_version", + version="4.0", + comparison_type="gt", + expected=False, + ), + VersionComparisonFixture( + test_id="gt_newer_version_with_letter", + version="4.0b", + comparison_type="gt", + expected=False, + ), + # Greater than or equal tests + VersionComparisonFixture( + test_id="gte_older_version", + version="1.6", + comparison_type="gte", + expected=True, + ), + VersionComparisonFixture( + test_id="gte_older_version_with_letter", + version="1.6b", + comparison_type="gte", + expected=True, + ), + VersionComparisonFixture( + test_id="gte_current_version", + version=str(get_version()), + comparison_type="gte", + expected=True, + ), + VersionComparisonFixture( + test_id="gte_newer_version", + version="4.0", + comparison_type="gte", + expected=False, + ), + VersionComparisonFixture( + test_id="gte_newer_version_with_letter", + version="4.0b", + comparison_type="gte", + expected=False, + ), + # Less than tests + VersionComparisonFixture( + test_id="lt_newer_version_with_letter", + version="4.0a", + comparison_type="lt", + expected=True, + ), + VersionComparisonFixture( + test_id="lt_newer_version", + version="4.0", + comparison_type="lt", + expected=True, + ), + VersionComparisonFixture( + test_id="lt_older_version", + version="1.7", + comparison_type="lt", + expected=False, + ), + VersionComparisonFixture( + test_id="lt_current_version", + version=str(get_version()), + comparison_type="lt", + expected=False, + ), + # Less than or equal tests + VersionComparisonFixture( + test_id="lte_newer_version_with_letter", + version="4.0a", + comparison_type="lte", + expected=True, + ), + VersionComparisonFixture( + test_id="lte_newer_version", + version="4.0", + comparison_type="lte", + expected=True, + ), + VersionComparisonFixture( + test_id="lte_current_version", + version=str(get_version()), + comparison_type="lte", + expected=True, + ), + VersionComparisonFixture( + test_id="lte_older_version", + version="1.7", + comparison_type="lte", + expected=False, + ), + VersionComparisonFixture( + test_id="lte_older_version_with_letter", + version="1.7b", + comparison_type="lte", + expected=False, + ), +] + + [email protected]( + list(VersionComparisonFixture._fields), + VERSION_COMPARISON_FIXTURES, + ids=[test.test_id for test in VERSION_COMPARISON_FIXTURES], +) +def test_version_comparison( + test_id: str, + version: str, + comparison_type: t.Literal["gt", "gte", "lt", "lte"], + expected: bool, +) -> None: + """Test version comparison functions.""" + comparison_funcs = { + "gt": has_gt_version, + "gte": has_gte_version, + "lt": has_lt_version, + "lte": has_lte_version, + } + assert comparison_funcs[comparison_type](version) == expected + + +class VersionParsingFixture(t.NamedTuple): + """Test fixture for version parsing and validation.""" + + test_id: str + mock_stdout: list[str] | None + mock_stderr: list[str] | None + mock_platform: str | None + expected_version: str | None + raises: bool + exc_msg_regex: str | None + + +VERSION_PARSING_FIXTURES: list[VersionParsingFixture] = [ + VersionParsingFixture( + test_id="master_version", + mock_stdout=["tmux master"], + mock_stderr=None, + mock_platform=None, + expected_version=f"{TMUX_MAX_VERSION}-master", + raises=False, + exc_msg_regex=None, + ), + VersionParsingFixture( + test_id="next_version", + mock_stdout=[f"tmux next-{float(TMUX_MAX_VERSION) + 0.1!s}"], + mock_stderr=None, + mock_platform=None, + expected_version=str(float(TMUX_MAX_VERSION) + 0.1), + raises=False, + exc_msg_regex=None, + ), + VersionParsingFixture( + test_id="openbsd_version", + mock_stdout=None, + mock_stderr=["tmux: unknown option -- V"], + mock_platform="openbsd 5.2", + expected_version=f"{TMUX_MAX_VERSION}-openbsd", + raises=False, + exc_msg_regex=None, + ), + VersionParsingFixture( + test_id="too_low_version", + mock_stdout=None, + mock_stderr=["tmux: unknown option -- V"], + mock_platform=None, + expected_version=None, + raises=True, + exc_msg_regex="is running tmux 1.3 or earlier", + ), +] + + [email protected]( + list(VersionParsingFixture._fields), + VERSION_PARSING_FIXTURES, + ids=[test.test_id for test in VERSION_PARSING_FIXTURES], +) +def test_version_parsing( + monkeypatch: pytest.MonkeyPatch, + test_id: str, + mock_stdout: list[str] | None, + mock_stderr: list[str] | None, + mock_platform: str | None, + expected_version: str | None, + raises: bool, + exc_msg_regex: str | None, +) -> None: + """Test version parsing and validation.""" + + class MockTmuxOutput: + stdout = mock_stdout + stderr = mock_stderr + + def mock_tmux_cmd(*args: t.Any, **kwargs: t.Any) -> MockTmuxOutput: + return MockTmuxOutput() + + monkeypatch.setattr(libtmux.common, "tmux_cmd", mock_tmux_cmd) + if mock_platform is not None: + monkeypatch.setattr(sys, "platform", mock_platform) + + if raises: + with pytest.raises(LibTmuxException) as exc_info: + get_version() + if exc_msg_regex is not None: + exc_info.match(exc_msg_regex) + else: + assert get_version() == expected_version + assert has_minimum_version() + assert has_gte_version(TMUX_MIN_VERSION) + assert has_gt_version(TMUX_MAX_VERSION) + + +class VersionValidationFixture(t.NamedTuple): + """Test fixture for version validation tests.""" + + test_id: str + mock_min_version: str | None + mock_version: str | None + check_type: t.Literal["min_version", "has_version", "type_check"] + raises: bool + exc_msg_regex: str | None + + +VERSION_VALIDATION_FIXTURES: list[VersionValidationFixture] = [ + # Letter version tests + VersionValidationFixture( + test_id="accepts_letter_in_min_version_1_9a", + mock_min_version="1.9a", + mock_version=None, + check_type="min_version", + raises=False, + exc_msg_regex=None, + ), + VersionValidationFixture( + test_id="accepts_letter_in_min_version_1_8a", + mock_min_version="1.8a", + mock_version=None, + check_type="min_version", + raises=False, + exc_msg_regex=None, + ), + VersionValidationFixture( + test_id="accepts_version_1_8", + mock_min_version=None, + mock_version="1.8", + check_type="type_check", + raises=False, + exc_msg_regex=None, + ), + VersionValidationFixture( + test_id="accepts_version_1_8a", + mock_min_version=None, + mock_version="1.8a", + check_type="type_check", + raises=False, + exc_msg_regex=None, + ), + VersionValidationFixture( + test_id="accepts_version_1_9a", + mock_min_version=None, + mock_version="1.9a", + check_type="type_check", + raises=False, + exc_msg_regex=None, + ), + # Version too low tests + VersionValidationFixture( + test_id="rejects_version_1_7", + mock_min_version=None, + mock_version="1.7", + check_type="min_version", + raises=True, + exc_msg_regex=r"libtmux only supports", + ), + # Additional test cases for version validation + VersionValidationFixture( + test_id="accepts_master_version", + mock_min_version=None, + mock_version="master", + check_type="type_check", + raises=False, + exc_msg_regex=None, + ), + VersionValidationFixture( + test_id="accepts_next_version", + mock_min_version=None, + mock_version="next-3.4", + check_type="type_check", + raises=False, + exc_msg_regex=None, + ), + VersionValidationFixture( + test_id="accepts_openbsd_version", + mock_min_version=None, + mock_version="3.3-openbsd", + check_type="type_check", + raises=False, + exc_msg_regex=None, + ), + VersionValidationFixture( + test_id="accepts_dev_version", + mock_min_version=None, + mock_version="3.3-dev", + check_type="type_check", + raises=False, + exc_msg_regex=None, + ), + VersionValidationFixture( + test_id="accepts_rc_version", + mock_min_version=None, + mock_version="3.3-rc2", + check_type="type_check", + raises=False, + exc_msg_regex=None, + ), +] + + [email protected]( + list(VersionValidationFixture._fields), + VERSION_VALIDATION_FIXTURES, + ids=[test.test_id for test in VERSION_VALIDATION_FIXTURES], +) +def test_version_validation( + monkeypatch: pytest.MonkeyPatch, + test_id: str, + mock_min_version: str | None, + mock_version: str | None, + check_type: t.Literal["min_version", "has_version", "type_check"], + raises: bool, + exc_msg_regex: str | None, +) -> None: + """Test version validation.""" + if mock_min_version is not None: + monkeypatch.setattr(libtmux.common, "TMUX_MIN_VERSION", mock_min_version) + + if mock_version is not None: + + def mock_get_version() -> LooseVersion: + return LooseVersion(mock_version) + + monkeypatch.setattr(libtmux.common, "get_version", mock_get_version) + + if check_type == "min_version": + if raises: + with pytest.raises(LibTmuxException) as exc_info: + has_minimum_version() + if exc_msg_regex is not None: + exc_info.match(exc_msg_regex) + else: + assert has_minimum_version() + elif check_type == "type_check": + assert mock_version is not None # For type checker + assert isinstance(has_version(mock_version), bool) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/tests/test_session.py new/libtmux-0.44.2/tests/test_session.py --- old/libtmux-0.44.1/tests/test_session.py 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/tests/test_session.py 2025-02-17 17:34:54.000000000 +0100 @@ -221,21 +221,39 @@ class PeriodRaisesBadSessionName(t.NamedTuple): """Test fixture for bad session name names.""" + test_id: str session_name: str raises: bool +PERIOD_RAISES_BAD_SESSION_NAME_FIXTURES: list[PeriodRaisesBadSessionName] = [ + PeriodRaisesBadSessionName( + test_id="period_in_name", + session_name="hey.period", + raises=True, + ), + PeriodRaisesBadSessionName( + test_id="colon_in_name", + session_name="hey:its a colon", + raises=True, + ), + PeriodRaisesBadSessionName( + test_id="valid_name", + session_name="hey moo", + raises=False, + ), +] + + @pytest.mark.parametrize( - PeriodRaisesBadSessionName._fields, - [ - PeriodRaisesBadSessionName("hey.period", True), - PeriodRaisesBadSessionName("hey:its a colon", True), - PeriodRaisesBadSessionName("hey moo", False), - ], + list(PeriodRaisesBadSessionName._fields), + PERIOD_RAISES_BAD_SESSION_NAME_FIXTURES, + ids=[test.test_id for test in PERIOD_RAISES_BAD_SESSION_NAME_FIXTURES], ) def test_periods_raise_bad_session_name( server: Server, session: Session, + test_id: str, session_name: str, raises: bool, ) -> None: @@ -275,19 +293,37 @@ assert cmd.cmd[-1] == last_arg +class SessionWindowEnvironmentFixture(t.NamedTuple): + """Test fixture for window environment variables in sessions.""" + + test_id: str + environment: dict[str, str] + + +SESSION_WINDOW_ENV_FIXTURES: list[SessionWindowEnvironmentFixture] = [ + SessionWindowEnvironmentFixture( + test_id="single_env_var", + environment={"ENV_VAR": "window"}, + ), + SessionWindowEnvironmentFixture( + test_id="multiple_env_vars", + environment={"ENV_VAR_1": "window_1", "ENV_VAR_2": "window_2"}, + ), +] + + @pytest.mark.skipif( has_lt_version("3.0"), reason="needs -e flag for new-window which was introduced in 3.0", ) @pytest.mark.parametrize( - "environment", - [ - {"ENV_VAR": "window"}, - {"ENV_VAR_1": "window_1", "ENV_VAR_2": "window_2"}, - ], + list(SessionWindowEnvironmentFixture._fields), + SESSION_WINDOW_ENV_FIXTURES, + ids=[test.test_id for test in SESSION_WINDOW_ENV_FIXTURES], ) def test_new_window_with_environment( session: Session, + test_id: str, environment: dict[str, str], ) -> None: """Verify new window with environment vars.""" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/tests/test_version.py new/libtmux-0.44.2/tests/test_version.py --- old/libtmux-0.44.1/tests/test_version.py 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/tests/test_version.py 2025-02-17 17:34:54.000000000 +0100 @@ -27,20 +27,31 @@ ] +class VersionTestFixture(t.NamedTuple): + """Test fixture for version string validation.""" + + test_id: str + version: str + + +VERSION_TEST_FIXTURES: list[VersionTestFixture] = [ + VersionTestFixture(test_id="simple_version", version="1"), + VersionTestFixture(test_id="minor_version", version="1.0"), + VersionTestFixture(test_id="patch_version", version="1.0.0"), + VersionTestFixture(test_id="beta_version", version="1.0.0b"), + VersionTestFixture(test_id="beta_with_number", version="1.0.0b1"), + VersionTestFixture(test_id="beta_with_os", version="1.0.0b-openbsd"), + VersionTestFixture(test_id="next_version", version="1.0.0-next"), + VersionTestFixture(test_id="next_with_number", version="1.0.0-next.1"), +] + + @pytest.mark.parametrize( - "version", - [ - "1", - "1.0", - "1.0.0", - "1.0.0b", - "1.0.0b1", - "1.0.0b-openbsd", - "1.0.0-next", - "1.0.0-next.1", - ], + list(VersionTestFixture._fields), + VERSION_TEST_FIXTURES, + ids=[test.test_id for test in VERSION_TEST_FIXTURES], ) -def test_version(version: str) -> None: +def test_version(test_id: str, version: str) -> None: """Assert LooseVersion constructor against various version strings.""" assert LooseVersion(version) @@ -48,27 +59,87 @@ class VersionCompareFixture(t.NamedTuple): """Test fixture for version comparison.""" + test_id: str a: object op: VersionCompareOp b: object raises: type[Exception] | bool +VERSION_COMPARE_FIXTURES: list[VersionCompareFixture] = [ + VersionCompareFixture( + test_id="equal_simple", + a="1", + op=operator.eq, + b="1", + raises=False, + ), + VersionCompareFixture( + test_id="equal_with_minor", + a="1", + op=operator.eq, + b="1.0", + raises=False, + ), + VersionCompareFixture( + test_id="equal_with_patch", + a="1", + op=operator.eq, + b="1.0.0", + raises=False, + ), + VersionCompareFixture( + test_id="greater_than_alpha", + a="1", + op=operator.gt, + b="1.0.0a", + raises=False, + ), + VersionCompareFixture( + test_id="greater_than_beta", + a="1", + op=operator.gt, + b="1.0.0b", + raises=False, + ), + VersionCompareFixture( + test_id="less_than_patch", + a="1", + op=operator.lt, + b="1.0.0p1", + raises=False, + ), + VersionCompareFixture( + test_id="less_than_openbsd", + a="1", + op=operator.lt, + b="1.0.0-openbsd", + raises=False, + ), + VersionCompareFixture( + test_id="less_than_equal_raises", + a="1", + op=operator.lt, + b="1", + raises=AssertionError, + ), + VersionCompareFixture( + test_id="beta_to_rc_compare", + a="1.0.0c", + op=operator.gt, + b="1.0.0b", + raises=False, + ), +] + + @pytest.mark.parametrize( - VersionCompareFixture._fields, - [ - VersionCompareFixture(a="1", op=operator.eq, b="1", raises=False), - VersionCompareFixture(a="1", op=operator.eq, b="1.0", raises=False), - VersionCompareFixture(a="1", op=operator.eq, b="1.0.0", raises=False), - VersionCompareFixture(a="1", op=operator.gt, b="1.0.0a", raises=False), - VersionCompareFixture(a="1", op=operator.gt, b="1.0.0b", raises=False), - VersionCompareFixture(a="1", op=operator.lt, b="1.0.0p1", raises=False), - VersionCompareFixture(a="1", op=operator.lt, b="1.0.0-openbsd", raises=False), - VersionCompareFixture(a="1", op=operator.lt, b="1", raises=AssertionError), - VersionCompareFixture(a="1.0.0c", op=operator.gt, b="1.0.0b", raises=False), - ], + list(VersionCompareFixture._fields), + VERSION_COMPARE_FIXTURES, + ids=[test.test_id for test in VERSION_COMPARE_FIXTURES], ) def test_version_compare( + test_id: str, a: str, op: VersionCompareOp, b: str, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/tests/test_window.py new/libtmux-0.44.2/tests/test_window.py --- old/libtmux-0.44.1/tests/test_window.py 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/tests/test_window.py 2025-02-17 17:34:54.000000000 +0100 @@ -211,33 +211,53 @@ assert pane.pane_width == str(int(window_width_before * 0.1)) +class WindowRenameFixture(t.NamedTuple): + """Test fixture for window rename functionality.""" + + test_id: str + window_name_before: str + window_name_input: str + window_name_after: str + + +WINDOW_RENAME_FIXTURES: list[WindowRenameFixture] = [ + WindowRenameFixture( + test_id="rename_with_spaces", + window_name_before="test", + window_name_input="ha ha ha fjewlkjflwef", + window_name_after="ha ha ha fjewlkjflwef", + ), + WindowRenameFixture( + test_id="rename_with_escapes", + window_name_before=r"hello \ wazzup 0", + window_name_input=r"hello \ wazzup 0", + window_name_after=r"hello \\ wazzup 0", + ), +] + + @pytest.mark.parametrize( - ("window_name_before", "window_name_after"), - [("test", "ha ha ha fjewlkjflwef"), ("test", "hello \\ wazzup 0")], + list(WindowRenameFixture._fields), + WINDOW_RENAME_FIXTURES, + ids=[test.test_id for test in WINDOW_RENAME_FIXTURES], ) def test_window_rename( session: Session, + test_id: str, window_name_before: str, + window_name_input: str, window_name_after: str, ) -> None: """Test Window.rename_window().""" - window_name_before = "test" - window_name_after = "ha ha ha fjewlkjflwef" - session.set_option("automatic-rename", "off") window = session.new_window(window_name=window_name_before, attach=True) assert window == session.active_window assert window.window_name == window_name_before - window.rename_window(window_name_after) - - window = session.active_window - - assert window.window_name == window_name_after + window.rename_window(window_name_input) window = session.active_window - assert window.window_name == window_name_after @@ -385,24 +405,42 @@ assert "''" in cmd.stdout +class WindowSplitEnvironmentFixture(t.NamedTuple): + """Test fixture for window split with environment variables.""" + + test_id: str + environment: dict[str, str] + + +WINDOW_SPLIT_ENV_FIXTURES: list[WindowSplitEnvironmentFixture] = [ + WindowSplitEnvironmentFixture( + test_id="single_env_var", + environment={"ENV_VAR": "pane"}, + ), + WindowSplitEnvironmentFixture( + test_id="multiple_env_vars", + environment={"ENV_VAR_1": "pane_1", "ENV_VAR_2": "pane_2"}, + ), +] + + @pytest.mark.skipif( has_lt_version("3.0"), reason="needs -e flag for split-window which was introduced in 3.0", ) @pytest.mark.parametrize( - "environment", - [ - {"ENV_VAR": "pane"}, - {"ENV_VAR_1": "pane_1", "ENV_VAR_2": "pane_2"}, - ], + list(WindowSplitEnvironmentFixture._fields), + WINDOW_SPLIT_ENV_FIXTURES, + ids=[test.test_id for test in WINDOW_SPLIT_ENV_FIXTURES], ) def test_split_with_environment( session: Session, + test_id: str, environment: dict[str, str], ) -> None: """Verify splitting window with environment variables.""" env = shutil.which("env") - assert env is not None, "Cannot find usable `env` in Path." + assert env is not None, "Cannot find usable `env` in PATH." window = session.new_window(window_name="split_with_environment") pane = window.split( diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libtmux-0.44.1/uv.lock new/libtmux-0.44.2/uv.lock --- old/libtmux-0.44.1/uv.lock 2025-02-17 13:21:26.000000000 +0100 +++ new/libtmux-0.44.2/uv.lock 2025-02-17 17:34:54.000000000 +0100 @@ -378,7 +378,7 @@ [[package]] name = "libtmux" -version = "0.44.1" +version = "0.44.2" source = { editable = "." } [package.dev-dependencies]
