refactor! Refactor CLI tests

Author: tony

tests/cli/test_cli.py

@@ -0,0 +1,86 @@
+import io
+import json
+import pathlib
+import typing as t
+
+import pytest
+
+from tmuxp import cli
+
+
+@pytest.mark.parametrize(
+    "cli_args",
+    [
+        (["convert", "."]),
+        (["convert", ".tmuxp.yaml"]),
+        (["convert", ".tmuxp.yaml", "-y"]),
+        (["convert", ".tmuxp.yml"]),
+        (["convert", ".tmuxp.yml", "-y"]),
+    ],
+)
+def test_convert(
+    cli_args: t.List[str],
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # create dummy tmuxp yaml so we don't get yelled at
+    filename = cli_args[1]
+    if filename == ".":
+        filename = ".tmuxp.yaml"
+    file_ext = filename.rsplit(".", 1)[-1]
+    assert file_ext in ["yaml", "yml"], file_ext
+    workspace_file_path = tmp_path / filename
+    workspace_file_path.write_text("\nsession_name: hello\n", encoding="utf-8")
+    oh_my_zsh_path = tmp_path / ".oh-my-zsh"
+    oh_my_zsh_path.mkdir()
+    monkeypatch.setenv("HOME", str(tmp_path))
+
+    monkeypatch.chdir(tmp_path)
+
+    # If autoconfirm (-y) no need to prompt y
+    input_args = "y\ny\n" if "-y" not in cli_args else ""
+
+    monkeypatch.setattr("sys.stdin", io.StringIO(input_args))
+    try:
+        cli.cli(cli_args)
+    except SystemExit:
+        pass
+    tmuxp_json = tmp_path / ".tmuxp.json"
+    assert tmuxp_json.exists()
+    assert tmuxp_json.open().read() == json.dumps({"session_name": "hello"}, indent=2)
+
+
+@pytest.mark.parametrize(
+    "cli_args",
+    [
+        (["convert", "."]),
+        (["convert", ".tmuxp.json"]),
+        (["convert", ".tmuxp.json", "-y"]),
+    ],
+)
+def test_convert_json(
+    cli_args: t.List[str],
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # create dummy tmuxp yaml so we don't get yelled at
+    json_config = tmp_path / ".tmuxp.json"
+    json_config.write_text('{"session_name": "hello"}', encoding="utf-8")
+    oh_my_zsh_path = tmp_path / ".oh-my-zsh"
+    oh_my_zsh_path.mkdir()
+    monkeypatch.setenv("HOME", str(tmp_path))
+
+    monkeypatch.chdir(tmp_path)
+
+    # If autoconfirm (-y) no need to prompt y
+    input_args = "y\ny\n" if "-y" not in cli_args else ""
+
+    monkeypatch.setattr("sys.stdin", io.StringIO(input_args))
+    try:
+        cli.cli(cli_args)
+    except SystemExit:
+        pass
+
+    tmuxp_yaml = tmp_path / ".tmuxp.yaml"
+    assert tmuxp_yaml.exists()
+    assert tmuxp_yaml.open().read() == "session_name: hello\n"

tests/cli/test_convert.py

@@ -0,0 +1,30 @@
+import pathlib
+
+import pytest
+
+from tmuxp import cli
+
+
+def test_debug_info_cli(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: pathlib.Path,
+    capsys: pytest.CaptureFixture,
+) -> None:
+    monkeypatch.setenv("SHELL", "/bin/bash")
+
+    cli.cli(["debug-info"])
+    cli_output = capsys.readouterr().out
+    assert "environment" in cli_output
+    assert "python version" in cli_output
+    assert "system PATH" in cli_output
+    assert "tmux version" in cli_output
+    assert "libtmux version" in cli_output
+    assert "tmuxp version" in cli_output
+    assert "tmux path" in cli_output
+    assert "tmuxp path" in cli_output
+    assert "shell" in cli_output
+    assert "tmux session" in cli_output
+    assert "tmux windows" in cli_output
+    assert "tmux panes" in cli_output
+    assert "tmux global options" in cli_output
+    assert "tmux window options" in cli_output

tests/cli/test_debug_info.py

@@ -0,0 +1,105 @@
+import io
+import pathlib
+import typing as t
+
+import pytest
+
+from libtmux.server import Server
+from tmuxp import cli
+from tmuxp.config_reader import ConfigReader
+
+
+@pytest.mark.parametrize(
+    "cli_args,inputs",
+    [
+        (["freeze", "myfrozensession"], ["y\n", "./la.yaml\n", "y\n"]),
+        (  # Exists
+            ["freeze", "myfrozensession"],
+            ["y\n", "./exists.yaml\n", "./la.yaml\n", "y\n"],
+        ),
+        (  # Imply current session if not entered
+            ["freeze"],
+            ["y\n", "./la.yaml\n", "y\n"],
+        ),
+        (["freeze"], ["y\n", "./exists.yaml\n", "./la.yaml\n", "y\n"]),  # Exists
+    ],
+)
+def test_freeze(
+    server: "Server",
+    cli_args: t.List[str],
+    inputs: t.List[str],
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    exists_yaml = tmp_path / "exists.yaml"
+    exists_yaml.touch()
+
+    server.new_session(session_name="myfirstsession")
+    server.new_session(session_name="myfrozensession")
+
+    # Assign an active pane to the session
+    second_session = server.sessions[1]
+    first_pane_on_second_session_id = second_session.windows[0].panes[0].pane_id
+    assert first_pane_on_second_session_id
+    monkeypatch.setenv("TMUX_PANE", first_pane_on_second_session_id)
+
+    monkeypatch.chdir(tmp_path)
+    # Use tmux server (socket name) used in the test
+    assert server.socket_name is not None
+    cli_args = cli_args + ["-L", server.socket_name]
+
+    monkeypatch.setattr("sys.stdin", io.StringIO("".join(inputs)))
+    try:
+        cli.cli(cli_args)
+    except SystemExit:
+        pass
+
+    yaml_config_path = tmp_path / "la.yaml"
+    assert yaml_config_path.exists()
+
+    yaml_config = yaml_config_path.open().read()
+    frozen_config = ConfigReader._load(format="yaml", content=yaml_config)
+
+    assert frozen_config["session_name"] == "myfrozensession"
+
+
+@pytest.mark.parametrize(
+    "cli_args,inputs",
+    [
+        (  # Overwrite
+            ["freeze", "mysession", "--force"],
+            ["\n", "\n", "y\n", "./exists.yaml\n", "y\n"],
+        ),
+        (  # Imply current session if not entered
+            ["freeze", "--force"],
+            ["\n", "\n", "y\n", "./exists.yaml\n", "y\n"],
+        ),
+    ],
+)
+def test_freeze_overwrite(
+    server: "Server",
+    cli_args: t.List[str],
+    inputs: t.List[str],
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    exists_yaml = tmp_path / "exists.yaml"
+    exists_yaml.touch()
+
+    server.new_session(session_name="mysession")
+
+    monkeypatch.chdir(tmp_path)
+    # Use tmux server (socket name) used in the test
+    assert server.socket_name is not None
+    cli_args = cli_args + ["-L", server.socket_name]
+
+    monkeypatch.setattr("sys.stdin", io.StringIO("".join(inputs)))
+    try:
+        cli.cli(cli_args)
+    except SystemExit:
+        pass
+
+    yaml_config_path = tmp_path / "exists.yaml"
+    assert yaml_config_path.exists()

tests/cli/test_freeze.py

@@ -0,0 +1,118 @@
+import io
+import pathlib
+import typing as t
+
+import pytest
+
+from tmuxp import cli
+
+from ..fixtures import utils as test_utils
+
+
+@pytest.mark.parametrize("cli_args", [(["import"])])
+def test_import(
+    cli_args: t.List[str],
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture,
+) -> None:
+    cli.cli(cli_args)
+    result = capsys.readouterr()
+    assert "tmuxinator" in result.out
+    assert "teamocil" in result.out
+
+
+@pytest.mark.parametrize(
+    "cli_args,inputs",
+    [
+        (
+            ["import", "teamocil", "./.teamocil/config.yaml"],
+            ["\n", "y\n", "./la.yaml\n", "y\n"],
+        ),
+        (
+            ["import", "teamocil", "./.teamocil/config.yaml"],
+            ["\n", "y\n", "./exists.yaml\n", "./la.yaml\n", "y\n"],
+        ),
+        (
+            ["import", "teamocil", "config"],
+            ["\n", "y\n", "./exists.yaml\n", "./la.yaml\n", "y\n"],
+        ),
+    ],
+)
+def test_import_teamocil(
+    cli_args: t.List[str],
+    inputs: t.List[str],
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    teamocil_config = test_utils.read_workspace_file("import_teamocil/test4.yaml")
+
+    teamocil_path = tmp_path / ".teamocil"
+    teamocil_path.mkdir()
+
+    teamocil_config_path = teamocil_path / "config.yaml"
+    teamocil_config_path.write_text(teamocil_config, encoding="utf-8")
+
+    exists_yaml = tmp_path / "exists.yaml"
+    exists_yaml.touch()
+
+    monkeypatch.setenv("HOME", str(tmp_path))
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr("sys.stdin", io.StringIO("".join(inputs)))
+
+    try:
+        cli.cli(cli_args)
+    except SystemExit:
+        pass
+
+    new_config_yaml = tmp_path / "la.yaml"
+    assert new_config_yaml.exists()
+
+
+@pytest.mark.parametrize(
+    "cli_args,inputs",
+    [
+        (
+            ["import", "tmuxinator", "./.tmuxinator/config.yaml"],
+            ["\n", "y\n", "./la.yaml\n", "y\n"],
+        ),
+        (
+            ["import", "tmuxinator", "./.tmuxinator/config.yaml"],
+            ["\n", "y\n", "./exists.yaml\n", "./la.yaml\n", "y\n"],
+        ),
+        (
+            ["import", "tmuxinator", "config"],
+            ["\n", "y\n", "./exists.yaml\n", "./la.yaml\n", "y\n"],
+        ),
+    ],
+)
+def test_import_tmuxinator(
+    cli_args: t.List[str],
+    inputs: t.List[str],
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    tmuxinator_config = test_utils.read_workspace_file("import_tmuxinator/test3.yaml")
+
+    tmuxinator_path = tmp_path / ".tmuxinator"
+    tmuxinator_path.mkdir()
+
+    tmuxinator_config_path = tmuxinator_path / "config.yaml"
+    tmuxinator_config_path.write_text(tmuxinator_config, encoding="utf-8")
+
+    exists_yaml = tmp_path / "exists.yaml"
+    exists_yaml.touch()
+
+    monkeypatch.setenv("HOME", str(tmp_path))
+
+    monkeypatch.chdir(tmp_path)
+
+    monkeypatch.setattr("sys.stdin", io.StringIO("".join(inputs)))
+    try:
+        cli.cli(cli_args)
+    except SystemExit:
+        pass
+
+    new_config_yaml = tmp_path / "la.yaml"
+    assert new_config_yaml.exists()

tests/cli/test_import.py

@@ -0,0 +1,45 @@
+import os
+import pathlib
+
+import pytest
+
+from tmuxp import cli
+
+
+def test_ls_cli(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: pathlib.Path,
+    capsys: pytest.CaptureFixture,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / ".config"))
+
+    filenames = [
+        ".git/",
+        ".gitignore/",
+        "session_1.yaml",
+        "session_2.yaml",
+        "session_3.json",
+        "session_4.txt",
+    ]
+
+    # should ignore:
+    # - directories should be ignored
+    # - extensions not covered in VALID_WORKSPACE_DIR_FILE_EXTENSIONS
+    ignored_filenames = [".git/", ".gitignore/", "session_4.txt"]
+    stems = [os.path.splitext(f)[0] for f in filenames if f not in ignored_filenames]
+
+    for filename in filenames:
+        location = tmp_path / f".tmuxp/{filename}"
+        if filename.endswith("/"):
+            location.mkdir(parents=True)
+        else:
+            location.touch()
+
+    try:
+        cli.cli(["ls"])
+    except SystemExit:
+        pass
+    cli_output = capsys.readouterr().out
+
+    assert cli_output == "\n".join(stems) + "\n"

tests/cli/test_load.py

@@ -0,0 +1,288 @@
+import io
+import pathlib
+import subprocess
+import typing as t
+
+import pytest
+
+from libtmux.server import Server
+from libtmux.session import Session
+from tmuxp import cli, exc
+
+
+@pytest.mark.parametrize("cli_cmd", [["shell"], ["shell", "--pdb"]])
+@pytest.mark.parametrize(
+    "cli_args,inputs,env,expected_output",
+    [
+        (
+            ["-L{SOCKET_NAME}", "-c", "print(str(server.socket_name))"],
+            [],
+            {},
+            "{SERVER_SOCKET_NAME}",
+        ),
+        (
+            [
+                "-L{SOCKET_NAME}",
+                "{SESSION_NAME}",
+                "-c",
+                "print(session.name)",
+            ],
+            [],
+            {},
+            "{SESSION_NAME}",
+        ),
+        (
+            [
+                "-L{SOCKET_NAME}",
+                "{SESSION_NAME}",
+                "{WINDOW_NAME}",
+                "-c",
+                "print(server.has_session(session.name))",
+            ],
+            [],
+            {},
+            "True",
+        ),
+        (
+            [
+                "-L{SOCKET_NAME}",
+                "{SESSION_NAME}",
+                "{WINDOW_NAME}",
+                "-c",
+                "print(window.name)",
+            ],
+            [],
+            {},
+            "{WINDOW_NAME}",
+        ),
+        (
+            [
+                "-L{SOCKET_NAME}",
+                "{SESSION_NAME}",
+                "{WINDOW_NAME}",
+                "-c",
+                "print(pane.id)",
+            ],
+            [],
+            {},
+            "{PANE_ID}",
+        ),
+        (
+            [
+                "-L{SOCKET_NAME}",
+                "-c",
+                "print(pane.id)",
+            ],
+            [],
+            {"TMUX_PANE": "{PANE_ID}"},
+            "{PANE_ID}",
+        ),
+    ],
+)
+def test_shell(
+    cli_cmd: t.List[str],
+    cli_args: t.List[str],
+    inputs: t.List[t.Any],
+    expected_output: str,
+    env: t.Dict[str, str],
+    server: "Server",
+    session: Session,
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    window_name = "my_window"
+    window = session.new_window(window_name=window_name)
+    window.split_window()
+
+    assert window.attached_pane is not None
+
+    template_ctx = dict(
+        SOCKET_NAME=server.socket_name,
+        SESSION_NAME=session.name,
+        WINDOW_NAME=window_name,
+        PANE_ID=window.attached_pane.id,
+        SERVER_SOCKET_NAME=server.socket_name,
+    )
+
+    cli_args = cli_cmd + [cli_arg.format(**template_ctx) for cli_arg in cli_args]
+
+    for k, v in env.items():
+        monkeypatch.setenv(k, v.format(**template_ctx))
+
+    monkeypatch.chdir(tmp_path)
+
+    cli.cli(cli_args)
+    result = capsys.readouterr()
+    assert expected_output.format(**template_ctx) in result.out
+
+
+@pytest.mark.parametrize(
+    "cli_cmd",
+    [
+        ["shell"],
+        ["shell", "--pdb"],
+    ],
+)
+@pytest.mark.parametrize(
+    "cli_args,inputs,env,template_ctx,exception,message",
+    [
+        (
+            ["-LDoesNotExist", "-c", "print(str(server.socket_name))"],
+            [],
+            {},
+            {},
+            subprocess.CalledProcessError,
+            r".*DoesNotExist.*",
+        ),
+        (
+            [
+                "-L{SOCKET_NAME}",
+                "nonexistant_session",
+                "-c",
+                "print(str(server.socket_name))",
+            ],
+            [],
+            {},
+            {"session_name": "nonexistant_session"},
+            exc.TmuxpException,
+            "Session not found: nonexistant_session",
+        ),
+        (
+            [
+                "-L{SOCKET_NAME}",
+                "{SESSION_NAME}",
+                "nonexistant_window",
+                "-c",
+                "print(str(server.socket_name))",
+            ],
+            [],
+            {},
+            {"window_name": "nonexistant_window"},
+            exc.TmuxpException,
+            "Window not found: {WINDOW_NAME}",
+        ),
+    ],
+)
+def test_shell_target_missing(
+    cli_cmd: t.List[str],
+    cli_args: t.List[str],
+    inputs: t.List[t.Any],
+    env: t.Dict[t.Any, t.Any],
+    template_ctx: t.Dict[str, str],
+    exception: t.Union[
+        t.Type[exc.TmuxpException], t.Type[subprocess.CalledProcessError]
+    ],
+    message: str,
+    socket_name: str,
+    server: "Server",
+    session: Session,
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    window_name = "my_window"
+    window = session.new_window(window_name=window_name)
+    window.split_window()
+
+    assert server.socket_name is not None
+    assert session.name is not None
+
+    template_ctx.update(
+        dict(
+            SOCKET_NAME=server.socket_name,
+            SESSION_NAME=session.name,
+            WINDOW_NAME=template_ctx.get("window_name", window_name),
+        )
+    )
+    cli_args = cli_cmd + [cli_arg.format(**template_ctx) for cli_arg in cli_args]
+
+    for k, v in env.items():
+        monkeypatch.setenv(k, v.format(**template_ctx))
+
+    monkeypatch.chdir(tmp_path)
+
+    if exception is not None:
+        with pytest.raises(exception, match=message.format(**template_ctx)):
+            cli.cli(cli_args)
+    else:
+        cli.cli(cli_args)
+        result = capsys.readouterr()
+        assert message.format(**template_ctx) in result.out
+
+
+@pytest.mark.parametrize(
+    "cli_cmd",
+    [
+        # ['shell'],
+        # ['shell', '--pdb'),
+        ["shell", "--code"],
+        # ['shell', '--bpython'],
+        # ['shell', '--ptipython'],
+        # ['shell', '--ptpython'],
+        # ['shell', '--ipython'],
+    ],
+)
+@pytest.mark.parametrize(
+    "cli_args,inputs,env,message",
+    [
+        (
+            [
+                "-L{SOCKET_NAME}",
+            ],
+            [],
+            {},
+            "(InteractiveConsole)",
+        ),
+        (
+            [
+                "-L{SOCKET_NAME}",
+            ],
+            [],
+            {"PANE_ID": "{PANE_ID}"},
+            "(InteractiveConsole)",
+        ),
+    ],
+)
+def test_shell_interactive(
+    cli_cmd: t.List[str],
+    cli_args: t.List[str],
+    inputs: t.List[t.Any],
+    env: t.Dict[str, str],
+    message: str,
+    server: "Server",
+    session: Session,
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    window_name = "my_window"
+    window = session.new_window(window_name=window_name)
+    window.split_window()
+
+    assert window.attached_pane is not None
+
+    template_ctx = dict(
+        SOCKET_NAME=server.socket_name,
+        SESSION_NAME=session.name,
+        WINDOW_NAME=window_name,
+        PANE_ID=window.attached_pane.id,
+        SERVER_SOCKET_NAME=server.socket_name,
+    )
+
+    cli_args = cli_cmd + [cli_arg.format(**template_ctx) for cli_arg in cli_args]
+
+    for k, v in env.items():
+        monkeypatch.setenv(k, v.format(**template_ctx))
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr("sys.stdin", io.StringIO("exit()\r"))
+    try:
+        cli.cli(cli_args)
+    except SystemExit:
+        pass
+    result = capsys.readouterr()
+    assert message.format(**template_ctx) in result.err