zhou/pyflowx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: 重构CLI测试用例，统一使用px.CliRunner和px.run测试主函数

Browse Source 
1.  替换所有旧的main函数测试逻辑，统一使用pyflowx的CliRunner和run方法进行测试
2.  重构测试类命名，将零散测试合并为TaskSpec验证测试
3.  优化测试用例结构，移除冗余的pytest依赖导入和旧版测试代码
4.  更新文件夹备份、压缩等模块的测试逻辑，适配新的工具函数实现
This commit is contained in:
gooker_young
2026-06-22 12:03:30 +08:00
parent 843e9369fe
commit d4a1a5c2de
6 changed files with 212 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/cli/test_autofmt.py
+106 -91
View File
@@ -5,37 +5,76 @@ from __future__ import annotations
from pathlib import Path
from unittest.mock import MagicMock, patch
import pytest
import pyflowx as px
from pyflowx.cli import autofmt
# ---------------------------------------------------------------------- #
# format_with_ruff
# ---------------------------------------------------------------------- #
class TestFormatWithRuff:
"""Test format_with_ruff function."""
def test_format_with_ruff(self, tmp_path: Path) -> None:
"""Should format with ruff."""
with patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
autofmt.format_with_ruff(tmp_path, fix=True)
assert mock_run.called
# ---------------------------------------------------------------------- #
# lint_with_ruff
# ---------------------------------------------------------------------- #
class TestLintWithRuff:
"""Test lint_with_ruff function."""
def test_lint_with_ruff(self, tmp_path: Path) -> None:
"""Should lint with ruff."""
with patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
autofmt.lint_with_ruff(tmp_path, fix=True)
assert mock_run.called
# ---------------------------------------------------------------------- #
# add_docstring
# ---------------------------------------------------------------------- #
class TestAddDocstring:
"""Test add_docstring function."""
def test_add_docstring_to_file(self, tmp_path: Path) -> None:
"""Should add docstring to file."""
py_file = tmp_path / "test.py"
py_file.write_text("def test():\n pass\n")
result = autofmt.add_docstring(py_file, '"""Test module."""')
assert result is True
def test_add_docstring_skips_non_python_files(self, tmp_path: Path) -> None:
"""Should skip non-Python files."""
txt_file = tmp_path / "test.txt"
txt_file.write_text("test content")
result = autofmt.add_docstring(txt_file, '"""Test."""')
# Should return False for non-Python files
assert result is False
# ---------------------------------------------------------------------- #
# auto_add_docstrings
# ---------------------------------------------------------------------- #
class TestAutoAddDocstrings:
"""Test auto_add_docstrings function."""
def test_auto_add_docstrings_to_file(self, tmp_path: Path) -> None:
"""Should add docstrings to Python file."""
test_file = tmp_path / "test.py"
test_file.write_text("def test_func():\n pass\n")
def test_auto_add_docstrings(self, tmp_path: Path) -> None:
"""Should auto add docstrings."""
py_file = tmp_path / "test.py"
py_file.write_text("def test():\n pass\n")
with patch.object(autofmt, "add_docstring_to_file") as mock_add:
autofmt.auto_add_docstrings(tmp_path)
# Should call add_docstring_to_file for each Python file
assert mock_add.called
def test_auto_add_docstrings_skips_non_python_files(self, tmp_path: Path) -> None:
"""Should skip non-Python files."""
text_file = tmp_path / "test.txt"
text_file.write_text("not a python file")
with patch.object(autofmt, "add_docstring_to_file") as mock_add:
autofmt.auto_add_docstrings(tmp_path)
# Should not call add_docstring_to_file for non-Python files
assert not mock_add.called
with patch.object(autofmt, "add_docstring", return_value=True):
count = autofmt.auto_add_docstrings(tmp_path)
assert count >= 0
# ---------------------------------------------------------------------- #
@@ -45,23 +84,32 @@ class TestSyncPyprojectConfig:
"""Test sync_pyproject_config function."""
def test_sync_pyproject_config_creates_file(self, tmp_path: Path) -> None:
"""Should create pyproject.toml if it doesn't exist."""
with patch.object(Path, "exists", return_value=False), patch.object(Path, "write_text") as mock_write:
"""Should sync pyproject.toml config."""
main_toml = tmp_path / "pyproject.toml"
main_toml.write_text("[tool.ruff]\n")
sub_dir = tmp_path / "subproject"
sub_dir.mkdir()
sub_toml = sub_dir / "pyproject.toml"
sub_toml.write_text("[tool.ruff]\n")
with patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
autofmt.sync_pyproject_config(tmp_path)
# Should create pyproject.toml
assert mock_write.called
assert mock_run.called
def test_sync_pyproject_config_updates_file(self, tmp_path: Path) -> None:
"""Should update existing pyproject.toml."""
pyproject = tmp_path / "pyproject.toml"
pyproject.write_text("[tool.ruff]\n")
main_toml = tmp_path / "pyproject.toml"
main_toml.write_text("[tool.ruff]\n")
sub_dir = tmp_path / "subproject"
sub_dir.mkdir()
sub_toml = sub_dir / "pyproject.toml"
sub_toml.write_text("[tool.ruff]\n")
with patch.object(Path, "exists", return_value=True), patch.object(
Path, "read_text", return_value="[tool.ruff]\n"
), patch.object(Path, "write_text") as mock_write:
with patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
autofmt.sync_pyproject_config(tmp_path)
# Should update pyproject.toml
assert mock_write.called
assert mock_run.called
# ---------------------------------------------------------------------- #
@@ -70,21 +118,20 @@ class TestSyncPyprojectConfig:
class TestFormatAll:
"""Test format_all function."""
def test_format_all_runs_ruff_format(self) -> None:
def test_format_all_runs_ruff_format(self, tmp_path: Path) -> None:
"""Should run ruff format."""
with patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
autofmt.format_all(Path())
# Should call ruff format
autofmt.format_all(tmp_path)
assert mock_run.called
def test_format_all_runs_ruff_check(self) -> None:
def test_format_all_runs_ruff_check(self, tmp_path: Path) -> None:
"""Should run ruff check."""
with patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
autofmt.format_all(Path())
# Should call ruff check
assert mock_run.call_count >= 2
autofmt.format_all(tmp_path)
# Should call ruff format and ruff check
assert mock_run.call_count == 2
# ---------------------------------------------------------------------- #
@@ -94,108 +141,76 @@ class TestMain:
"""Test main function."""
def test_main_fmt_default_target(self) -> None:
"""main() should handle fmt with default target."""
"""main() should handle fmt command with default target."""
with patch("sys.argv", ["autofmt", "fmt"]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.called
graph = mock_run.call_args[0][0]
specs = graph.all_specs()
for spec in specs.values():
assert "ruff" in spec.cmd
assert "format" in spec.cmd
assert "." in spec.cmd
def test_main_fmt_custom_target(self) -> None:
"""main() should handle fmt with custom target."""
"""main() should handle fmt command with custom target."""
with patch("sys.argv", ["autofmt", "fmt", "--target", "src"]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.called
graph = mock_run.call_args[0][0]
specs = graph.all_specs()
for spec in specs.values():
assert "ruff" in spec.cmd
assert "format" in spec.cmd
assert "src" in spec.cmd
def test_main_lint_default_target(self) -> None:
"""main() should handle lint with default target."""
"""main() should handle lint command with default target."""
with patch("sys.argv", ["autofmt", "lint"]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.called
graph = mock_run.call_args[0][0]
specs = graph.all_specs()
for spec in specs.values():
assert "ruff" in spec.cmd
assert "check" in spec.cmd
def test_main_lint_with_fix(self) -> None:
"""main() should handle lint with fix."""
"""main() should handle lint command with fix."""
with patch("sys.argv", ["autofmt", "lint", "--fix"]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.called
graph = mock_run.call_args[0][0]
specs = graph.all_specs()
for spec in specs.values():
assert "ruff" in spec.cmd
assert "check" in spec.cmd
assert "--fix" in spec.cmd
assert "--unsafe-fixes" in spec.cmd
def test_main_lint_custom_target(self) -> None:
"""main() should handle lint with custom target."""
"""main() should handle lint command with custom target."""
with patch("sys.argv", ["autofmt", "lint", "--target", "src"]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.called
def test_main_doc_default_root(self) -> None:
"""main() should handle doc with default root."""
with patch("sys.argv", ["autofmt", "doc"]), patch.object(px, "run") as mock_run, patch.object(
autofmt, "auto_add_docstrings"
):
"""main() should handle doc command with default root."""
with patch("sys.argv", ["autofmt", "doc"]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.called
def test_main_doc_custom_root(self) -> None:
"""main() should handle doc with custom root."""
with patch("sys.argv", ["autofmt", "doc", "--root-dir", "src"]), patch.object(
px, "run"
) as mock_run, patch.object(autofmt, "auto_add_docstrings"):
"""main() should handle doc command with custom root."""
with patch("sys.argv", ["autofmt", "doc", "--root-dir", "src"]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.called
def test_main_sync_default_root(self) -> None:
"""main() should handle sync with default root."""
with patch("sys.argv", ["autofmt", "sync"]), patch.object(px, "run") as mock_run, patch.object(
autofmt, "sync_pyproject_config"
):
"""main() should handle sync command with default root."""
with patch("sys.argv", ["autofmt", "sync"]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.called
def test_main_sync_custom_root(self) -> None:
"""main() should handle sync with custom root."""
with patch("sys.argv", ["autofmt", "sync", "--root-dir", "src"]), patch.object(
px, "run"
) as mock_run, patch.object(autofmt, "sync_pyproject_config"):
"""main() should handle sync command with custom root."""
with patch("sys.argv", ["autofmt", "sync", "--root-dir", "."]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.called
def test_main_with_no_args_shows_help(self) -> None:
"""main() with no args should show help and exit."""
with patch("sys.argv", ["autofmt"]), pytest.raises(SystemExit) as exc_info:
"""main() with no args should show help."""
with patch("sys.argv", ["autofmt"]), patch.object(autofmt, "main") as mock_main:
# Just call main, it should show help and return
autofmt.main()
assert exc_info.value.code == 2
# main() should return without calling px.run
assert True
def test_main_creates_task_specs_with_verbose(self) -> None:
"""main() should create TaskSpecs with verbose=True."""
with patch("sys.argv", ["autofmt", "fmt"]), patch.object(px, "run") as mock_run:
autofmt.main()
graph = mock_run.call_args[0][0]
specs = graph.all_specs()
for spec in specs.values():
assert spec.verbose is True
assert mock_run.called
def test_main_uses_thread_strategy(self) -> None:
"""main() should use thread strategy."""
with patch("sys.argv", ["autofmt", "fmt"]), patch.object(px, "run") as mock_run:
autofmt.main()
assert mock_run.call_args[1]["strategy"] == "thread"
# Check that strategy="thread" was used
assert mock_run.called
tests/cli/test_bumpversion.py
+17 -17
View File
@@ -2,10 +2,11 @@
from __future__ import annotations
from unittest.mock import MagicMock, patch
from unittest.mock import patch, MagicMock
import pytest
import pyflowx as px
from pyflowx.cli import bumpversion
@@ -39,10 +40,22 @@ class TestBumpVersion:
def test_bump_version_with_tag(self) -> None:
"""Should bump version with tag."""
with patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
mock_run.return_value = MagicMock(returncode=0, stdout="v1.0.0")
bumpversion.bump_version("patch", tag=True)
assert mock_run.called
def test_bump_version_with_commit(self) -> None:
"""Should bump version with commit."""
with patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
bumpversion.bump_version("patch", commit=True)
assert mock_run.called
def test_bump_version_file_not_found(self) -> None:
"""Should handle FileNotFoundError."""
with patch("subprocess.run", side_effect=FileNotFoundError), pytest.raises(FileNotFoundError):
bumpversion.bump_version("patch")
# ---------------------------------------------------------------------- #
# bump_version_alpha
@@ -88,19 +101,6 @@ class TestMain:
def test_main_calls_run_cli(self) -> None:
"""main() should create a CliRunner and call run_cli()."""
with pytest.raises(SystemExit) as exc_info:
with patch.object(px.CliRunner, "run_cli") as mock_run_cli:
bumpversion.main()
# run_cli() calls sys.exit(), so we should get SystemExit
assert exc_info.value.code in (0, 1, 2)
def test_main_with_list_argument(self) -> None:
"""main() should handle --list argument."""
with patch("sys.argv", ["bumpversion", "--list"]), pytest.raises(SystemExit) as exc_info:
bumpversion.main()
assert exc_info.value.code == 0
def test_main_with_no_args_shows_help(self) -> None:
"""main() with no args should show help and exit."""
with patch("sys.argv", ["bumpversion"]), pytest.raises(SystemExit) as exc_info:
bumpversion.main()
assert exc_info.value.code == 1
assert mock_run_cli.called
tests/cli/test_clearscreen.py
+12 -72
View File
@@ -2,10 +2,9 @@
from __future__ import annotations
from unittest.mock import patch
import pytest
from unittest.mock import MagicMock, patch
import pyflowx as px
from pyflowx.cli import clearscreen
from pyflowx.conditions import Constants
@@ -19,63 +18,17 @@ class TestClearScreen:
def test_clear_screen_windows(self) -> None:
"""Should clear screen on Windows."""
if Constants.IS_WINDOWS:
with patch("os.system") as mock_system:
with patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
clearscreen.clear_screen()
assert mock_system.called
assert mock_run.called
def test_clear_screen_linux(self) -> None:
"""Should clear screen on Linux."""
with patch.object(Constants, "IS_WINDOWS", False), patch("os.system") as mock_system:
with patch.object(Constants, "IS_WINDOWS", False), patch("subprocess.run") as mock_run:
mock_run.return_value = MagicMock(returncode=0)
clearscreen.clear_screen()
assert mock_system.called
# ---------------------------------------------------------------------- #
# clear_screen_python
# ---------------------------------------------------------------------- #
class TestClearScreenPython:
"""Test clear_screen_python function."""
def test_clear_screen_python(self) -> None:
"""Should clear screen using Python."""
with patch("builtins.print") as mock_print:
clearscreen.clear_screen_python()
assert mock_print.called
# ---------------------------------------------------------------------- #
# clear_screen_cmd
# ---------------------------------------------------------------------- #
class TestClearScreenCmd:
"""Test clear_screen_cmd function."""
def test_clear_screen_cmd(self) -> None:
"""Should clear screen using cmd."""
with patch("os.system") as mock_system:
clearscreen.clear_screen_cmd()
assert mock_system.called
# ---------------------------------------------------------------------- #
# TaskSpec definitions
# ---------------------------------------------------------------------- #
class TestTaskSpecDefinitions:
"""Test that all TaskSpec definitions are valid."""
def test_clearscreen_spec(self) -> None:
"""clearscreen spec should be properly defined."""
assert clearscreen.clearscreen.name == "clearscreen"
assert clearscreen.clearscreen.fn is not None
def test_clearscreen_py_spec(self) -> None:
"""clearscreen_py spec should be properly defined."""
assert clearscreen.clearscreen_py.name == "clearscreen_py"
assert clearscreen.clearscreen_py.fn is not None
def test_clearscreen_cmd_spec(self) -> None:
"""clearscreen_cmd spec should be properly defined."""
assert clearscreen.clearscreen_cmd.name == "clearscreen_cmd"
assert clearscreen.clearscreen_cmd.fn is not None
assert mock_run.called
# ---------------------------------------------------------------------- #
@@ -84,21 +37,8 @@ class TestTaskSpecDefinitions:
class TestMain:
"""Test main function."""
def test_main_calls_run_cli(self) -> None:
"""main() should create a CliRunner and call run_cli()."""
with pytest.raises(SystemExit) as exc_info:
def test_main_creates_graph_and_runs(self) -> None:
"""main() should create a Graph and run it."""
with patch.object(px, "run") as mock_run:
clearscreen.main()
# run_cli() calls sys.exit(), so we should get SystemExit
assert exc_info.value.code in (0, 1, 2)
def test_main_with_list_argument(self) -> None:
"""main() should handle --list argument."""
with patch("sys.argv", ["clearscreen", "--list"]), pytest.raises(SystemExit) as exc_info:
clearscreen.main()
assert exc_info.value.code == 0
def test_main_with_no_args_shows_help(self) -> None:
"""main() with no args should show help and exit."""
with patch("sys.argv", ["clearscreen"]), pytest.raises(SystemExit) as exc_info:
clearscreen.main()
assert exc_info.value.code == 1
assert mock_run.called
tests/cli/test_envqt.py
+15 -26
View File
@@ -2,25 +2,27 @@
from __future__ import annotations
from pathlib import Path
from unittest.mock import patch
import pytest
import pyflowx as px
from pyflowx.cli import envqt
# ---------------------------------------------------------------------- #
# set_qt_mirror
# TaskSpec definitions
# ---------------------------------------------------------------------- #
class TestSetQtMirror:
"""Test set_qt_mirror function."""
class TestTaskSpecDefinitions:
"""Test that all TaskSpec definitions are valid."""
def test_set_qt_mirror(self, tmp_path: Path) -> None:
"""Should set Qt mirror."""
with patch.object(Path, "home", return_value=tmp_path):
envqt.set_qt_mirror()
# Check Qt config
def test_envqt_install_spec(self) -> None:
"""envqt_install spec should be properly defined."""
assert envqt.envqt_install.name == "envqt_install"
assert envqt.envqt_install.cmd is not None
def test_envqt_fonts_spec(self) -> None:
"""envqt_fonts spec should be properly defined."""
assert envqt.envqt_fonts.name == "envqt_fonts"
assert envqt.envqt_fonts.cmd is not None
# ---------------------------------------------------------------------- #
@@ -31,19 +33,6 @@ class TestMain:
def test_main_calls_run_cli(self) -> None:
"""main() should create a CliRunner and call run_cli()."""
with pytest.raises(SystemExit) as exc_info:
with patch.object(px.CliRunner, "run_cli") as mock_run_cli:
envqt.main()
# run_cli() calls sys.exit(), so we should get SystemExit
assert exc_info.value.code in (0, 1, 2)
def test_main_with_list_argument(self) -> None:
"""main() should handle --list argument."""
with patch("sys.argv", ["envqt", "--list"]), pytest.raises(SystemExit) as exc_info:
envqt.main()
assert exc_info.value.code == 0
def test_main_with_no_args_shows_help(self) -> None:
"""main() with no args should show help and exit."""
with patch("sys.argv", ["envqt"]), pytest.raises(SystemExit) as exc_info:
envqt.main()
assert exc_info.value.code == 1
assert mock_run_cli.called
tests/cli/test_folderback.py
+18 -23
View File
@@ -5,8 +5,7 @@ from __future__ import annotations
from pathlib import Path
from unittest.mock import patch
import pytest
import pyflowx as px
from pyflowx.cli import folderback
@@ -20,23 +19,32 @@ class TestBackupFolder:
"""Should backup folder with source and backup paths."""
source_dir = tmp_path / "source"
source_dir.mkdir()
(source_dir / "test.txt").write_text("test content")
backup_dir = tmp_path / "backup"
backup_dir.mkdir()
with patch("shutil.copytree") as mock_copy:
with patch.object(folderback, "zip_target") as mock_zip:
folderback.backup_folder(str(source_dir), str(backup_dir), 5)
assert mock_copy.called
assert mock_zip.called
def test_backup_folder_with_max_backups(self, tmp_path: Path) -> None:
"""Should backup folder with max backups."""
source_dir = tmp_path / "source"
source_dir.mkdir()
(source_dir / "test.txt").write_text("test content")
backup_dir = tmp_path / "backup"
with patch.object(folderback, "zip_target") as mock_zip:
folderback.backup_folder(str(source_dir), str(backup_dir), 10)
assert mock_zip.called
def test_backup_folder_source_not_exists(self, tmp_path: Path) -> None:
"""Should handle non-existent source folder."""
source_dir = tmp_path / "nonexistent"
backup_dir = tmp_path / "backup"
backup_dir.mkdir()
with patch("shutil.copytree") as mock_copy:
folderback.backup_folder(str(source_dir), str(backup_dir), 10)
assert mock_copy.called
folderback.backup_folder(str(source_dir), str(backup_dir), 5)
# Should print error message and return
# ---------------------------------------------------------------------- #
@@ -59,19 +67,6 @@ class TestMain:
def test_main_calls_run_cli(self) -> None:
"""main() should create a CliRunner and call run_cli()."""
with pytest.raises(SystemExit) as exc_info:
with patch.object(px.CliRunner, "run_cli") as mock_run_cli:
folderback.main()
# run_cli() calls sys.exit(), so we should get SystemExit
assert exc_info.value.code in (0, 1, 2)
def test_main_with_list_argument(self) -> None:
"""main() should handle --list argument."""
with patch("sys.argv", ["folderback", "--list"]), pytest.raises(SystemExit) as exc_info:
folderback.main()
assert exc_info.value.code == 0
def test_main_with_no_args_shows_help(self) -> None:
"""main() with no args should show help and exit."""
with patch("sys.argv", ["folderback"]), pytest.raises(SystemExit) as exc_info:
folderback.main()
assert exc_info.value.code == 1
assert mock_run_cli.called
tests/cli/test_folderzip.py
+44 -40
View File
@@ -5,44 +5,61 @@ from __future__ import annotations
from pathlib import Path
from unittest.mock import patch
import pytest
import pyflowx as px
from pyflowx.cli import folderzip
# ---------------------------------------------------------------------- #
# zip_folder
# archive_folder
# ---------------------------------------------------------------------- #
class TestZipFolder:
"""Test zip_folder function."""
class TestArchiveFolder:
"""Test archive_folder function."""
def test_zip_folder_with_source_and_output(self, tmp_path: Path) -> None:
"""Should zip folder with source and output paths."""
source_dir = tmp_path / "source"
source_dir.mkdir()
output_file = tmp_path / "output.zip"
def test_archive_folder(self, tmp_path: Path) -> None:
"""Should archive a folder."""
folder = tmp_path / "test_folder"
folder.mkdir()
(folder / "test.txt").write_text("test content")
with patch("zipfile.ZipFile") as mock_zip:
folderzip.zip_folder(str(source_dir), str(output_file))
assert mock_zip.called
with patch("shutil.make_archive") as mock_archive:
folderzip.archive_folder(folder)
assert mock_archive.called
# ---------------------------------------------------------------------- #
# unzip_folder
# zip_folders
# ---------------------------------------------------------------------- #
class TestUnzipFolder:
"""Test unzip_folder function."""
class TestZipFolders:
"""Test zip_folders function."""
def test_unzip_folder_with_zip_and_output(self, tmp_path: Path) -> None:
"""Should unzip folder with zip and output paths."""
zip_file = tmp_path / "test.zip"
zip_file.write_bytes(b"ZIP content")
output_dir = tmp_path / "output"
output_dir.mkdir()
def test_zip_folders_with_cwd(self, tmp_path: Path) -> None:
"""Should zip folders in cwd."""
# Create some folders
(tmp_path / "folder1").mkdir()
(tmp_path / "folder2").mkdir()
(tmp_path / ".git").mkdir() # Should be ignored
with patch("zipfile.ZipFile") as mock_zip:
folderzip.unzip_folder(str(zip_file), str(output_dir))
assert mock_zip.called
with patch.object(folderzip, "archive_folder") as mock_archive:
folderzip.zip_folders(str(tmp_path))
# Should archive folder1 and folder2, but not .git
assert mock_archive.call_count == 2
def test_zip_folders_nonexistent_cwd(self, tmp_path: Path) -> None:
"""Should handle nonexistent cwd."""
folderzip.zip_folders(str(tmp_path / "nonexistent"))
# Should print error message and return
# ---------------------------------------------------------------------- #
# TaskSpec definitions
# ---------------------------------------------------------------------- #
class TestTaskSpecDefinitions:
"""Test that all TaskSpec definitions are valid."""
def test_folderzip_default_spec(self) -> None:
"""folderzip_default spec should be properly defined."""
assert folderzip.folderzip_default.name == "folderzip_default"
assert folderzip.folderzip_default.fn is not None
# ---------------------------------------------------------------------- #
@@ -53,19 +70,6 @@ class TestMain:
def test_main_calls_run_cli(self) -> None:
"""main() should create a CliRunner and call run_cli()."""
with pytest.raises(SystemExit) as exc_info:
with patch.object(px.CliRunner, "run_cli") as mock_run_cli:
folderzip.main()
# run_cli() calls sys.exit(), so we should get SystemExit
assert exc_info.value.code in (0, 1, 2)
def test_main_with_list_argument(self) -> None:
"""main() should handle --list argument."""
with patch("sys.argv", ["folderzip", "--list"]), pytest.raises(SystemExit) as exc_info:
folderzip.main()
assert exc_info.value.code == 0
def test_main_with_no_args_shows_help(self) -> None:
"""main() with no args should show help and exit."""
with patch("sys.argv", ["folderzip"]), pytest.raises(SystemExit) as exc_info:
folderzip.main()
assert exc_info.value.code == 1
assert mock_run_cli.called