diff --git a/CHANGES b/CHANGES index e0015f54c..fecc9a6c2 100644 --- a/CHANGES +++ b/CHANGES @@ -15,6 +15,15 @@ $ pip install --user --upgrade --pre libtmux - _Future release notes will be placed here_ +### 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 --git a/tests/test_common.py b/tests/test_common.py index fb32427e0..3d67182c1 100644 --- a/tests/test_common.py +++ b/tests/test_common.py @@ -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 @@ def test_tmux_cmd_unicode(session: Session) -> None: 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 @@ def test_get_libtmux_version() -> None: 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, + ), +] + + +@pytest.mark.parametrize( + 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", + ), +] + + +@pytest.mark.parametrize( + 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, + ), +] + + +@pytest.mark.parametrize( + 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 --git a/tests/test_session.py b/tests/test_session.py index 25c90f701..33b82dd72 100644 --- a/tests/test_session.py +++ b/tests/test_session.py @@ -221,21 +221,39 @@ def test_unset_environment(session: Session) -> None: 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 @@ def test_cmd_inserts_session_id(session: Session) -> None: 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 --git a/tests/test_version.py b/tests/test_version.py index f702a2c81..58df075a6 100644 --- a/tests/test_version.py +++ b/tests/test_version.py @@ -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 @@ def test_version(version: str) -> None: 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 --git a/tests/test_window.py b/tests/test_window.py index b08ad2d14..0be62613e 100644 --- a/tests/test_window.py +++ b/tests/test_window.py @@ -211,33 +211,53 @@ def test_split_size(session: Session) -> None: 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 @@ def test_empty_window_name(session: Session) -> None: 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(