From 413ab40044baa876014f5aebad544b5c21b27078 Mon Sep 17 00:00:00 2001 From: gooker_young Date: Mon, 22 Jun 2026 12:18:10 +0800 Subject: [PATCH] =?UTF-8?q?refactor(tests):=20=E9=87=8D=E6=9E=84=E6=B5=8B?= =?UTF-8?q?=E8=AF=95=E4=BB=A3=E7=A0=81=E5=B9=B6=E4=BC=98=E5=8C=96ruff?= =?UTF-8?q?=E6=A3=80=E6=9F=A5=E8=A7=84=E5=88=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1. 在pyproject.toml中为测试文件添加ARG001和ARG002规则忽略 2. 重构多个CLI测试文件，移除冗余的mock断言、导入顺序调整 3. 统一测试用例的帮助信息输出逻辑，移除SystemExit捕获，简化测试流程 4. 拆分合并冗余的测试类，按功能细化测试用例 5. 移除测试代码中多余的注释和pytest导入 --- pyproject.toml | 3 + tests/cli/test_autofmt.py | 2 +- tests/cli/test_bumpversion.py | 4 +- tests/cli/test_envpy.py | 6 +- tests/cli/test_envrs.py | 6 +- tests/cli/test_filedate.py | 177 ++++++++------- tests/cli/test_filelevel.py | 225 ++++++++----------- tests/cli/test_lscalc.py | 177 ++++++++------- tests/cli/test_packtool.py | 252 ++++++++------------- tests/cli/test_pdftool.py | 404 +++++++++++----------------------- tests/cli/test_piptool.py | 139 +++--------- tests/cli/test_screenshot.py | 162 ++++++-------- tests/test_context.py | 12 +- 13 files changed, 616 insertions(+), 953 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 9834604..45925a0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -148,6 +148,9 @@ select = [ "W", # pycodestyle warnings ] +[tool.ruff.lint.per-file-ignores] +"**/tests/**" = ["ARG001", "ARG002"] + [tool.pyrefly] preset = "basic" project-includes = ["**/*.ipynb", "**/*.py*"] diff --git a/tests/cli/test_autofmt.py b/tests/cli/test_autofmt.py index 8a4b99a..27c9aab 100644 --- a/tests/cli/test_autofmt.py +++ b/tests/cli/test_autofmt.py @@ -196,7 +196,7 @@ class TestMain: def test_main_with_no_args_shows_help(self) -> None: """main() with no args should show help.""" - with patch("sys.argv", ["autofmt"]), patch.object(autofmt, "main") as mock_main: + with patch("sys.argv", ["autofmt"]), patch.object(autofmt, "main"): # Just call main, it should show help and return autofmt.main() # main() should return without calling px.run diff --git a/tests/cli/test_bumpversion.py b/tests/cli/test_bumpversion.py index aa083ce..a72172f 100644 --- a/tests/cli/test_bumpversion.py +++ b/tests/cli/test_bumpversion.py @@ -2,7 +2,7 @@ from __future__ import annotations -from unittest.mock import patch, MagicMock +from unittest.mock import MagicMock, patch import pytest @@ -103,4 +103,4 @@ class TestMain: """main() should create a CliRunner and call run_cli().""" with patch.object(px.CliRunner, "run_cli") as mock_run_cli: bumpversion.main() - assert mock_run_cli.called \ No newline at end of file + assert mock_run_cli.called diff --git a/tests/cli/test_envpy.py b/tests/cli/test_envpy.py index 803eb91..3d95fab 100644 --- a/tests/cli/test_envpy.py +++ b/tests/cli/test_envpy.py @@ -80,10 +80,10 @@ class TestMain: 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", ["envpy"]), pytest.raises(SystemExit) as exc_info: + """main() with no args should show help and return.""" + with patch("sys.argv", ["envpy"]): envpy.main() - assert exc_info.value.code == 2 + # Should print help and return def test_main_invalid_mirror_shows_error(self) -> None: """main() with invalid mirror should show error.""" diff --git a/tests/cli/test_envrs.py b/tests/cli/test_envrs.py index b026414..0a2fc2d 100644 --- a/tests/cli/test_envrs.py +++ b/tests/cli/test_envrs.py @@ -172,10 +172,10 @@ class TestMain: 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", ["envrs"]), pytest.raises(SystemExit) as exc_info: + """main() with no args should show help and return.""" + with patch("sys.argv", ["envrs"]): envrs.main() - assert exc_info.value.code == 2 + # Should print help and return def test_main_invalid_version_shows_error(self) -> None: """main() with invalid version should show error.""" diff --git a/tests/cli/test_filedate.py b/tests/cli/test_filedate.py index f83316a..bda1d1c 100644 --- a/tests/cli/test_filedate.py +++ b/tests/cli/test_filedate.py @@ -5,49 +5,104 @@ from __future__ import annotations from pathlib import Path from unittest.mock import patch -import pytest - import pyflowx as px from pyflowx.cli import filedate +# ---------------------------------------------------------------------- # +# get_file_timestamp +# ---------------------------------------------------------------------- # +class TestGetFileTimestamp: + """Test get_file_timestamp function.""" + + def test_get_file_timestamp(self, tmp_path: Path) -> None: + """Should get file timestamp.""" + test_file = tmp_path / "test.txt" + test_file.write_text("test content") + + timestamp = filedate.get_file_timestamp(test_file) + assert len(timestamp) == 8 # YYYYMMDD format + assert timestamp.isdigit() + + +# ---------------------------------------------------------------------- # +# remove_date_prefix +# ---------------------------------------------------------------------- # +class TestRemoveDatePrefix: + """Test remove_date_prefix function.""" + + def test_remove_date_prefix_with_date(self, tmp_path: Path) -> None: + """Should remove date prefix from filename.""" + test_file = tmp_path / "20240101_test.txt" + test_file.write_text("test content") + + new_path = filedate.remove_date_prefix(test_file) + assert new_path.name == "test.txt" + + def test_remove_date_prefix_without_date(self, tmp_path: Path) -> None: + """Should not change filename without date prefix.""" + test_file = tmp_path / "test.txt" + test_file.write_text("test content") + + new_path = filedate.remove_date_prefix(test_file) + assert new_path == test_file + + +# ---------------------------------------------------------------------- # +# add_date_prefix +# ---------------------------------------------------------------------- # +class TestAddDatePrefix: + """Test add_date_prefix function.""" + + def test_add_date_prefix(self, tmp_path: Path) -> None: + """Should add date prefix to filename.""" + test_file = tmp_path / "test.txt" + test_file.write_text("test content") + + new_path = filedate.add_date_prefix(test_file) + assert new_path.name.startswith("20") # Starts with year + assert "_test.txt" in new_path.name + + +# ---------------------------------------------------------------------- # +# process_file_date +# ---------------------------------------------------------------------- # +class TestProcessFileDate: + """Test process_file_date function.""" + + def test_process_file_date_add(self, tmp_path: Path) -> None: + """Should add date prefix.""" + test_file = tmp_path / "test.txt" + test_file.write_text("test content") + + filedate.process_file_date(test_file, clear=False) + # File should be renamed with date prefix + + def test_process_file_date_clear(self, tmp_path: Path) -> None: + """Should clear date prefix.""" + test_file = tmp_path / "20240101_test.txt" + test_file.write_text("test content") + + filedate.process_file_date(test_file, clear=True) + # File should be renamed without date prefix + + # ---------------------------------------------------------------------- # # process_files_date # ---------------------------------------------------------------------- # class TestProcessFilesDate: """Test process_files_date function.""" - def test_process_files_date_add(self, tmp_path: Path) -> None: - """Should add date prefix.""" - test_file = tmp_path / "test.txt" - test_file.write_text("test content") - - with patch.object(filedate, "rename_file_with_date") as mock_rename: - filedate.process_files_date([test_file], clear=False) - assert mock_rename.called - - def test_process_files_date_clear(self, tmp_path: Path) -> None: - """Should clear date prefix.""" - test_file = tmp_path / "2024-01-01_test.txt" - test_file.write_text("test content") - - with patch.object(filedate, "rename_file_with_date") as mock_rename: - filedate.process_files_date([test_file], clear=True) - assert mock_rename.called - - def test_process_files_date_multiple_files(self, tmp_path: Path) -> None: + def test_process_files_date_batch(self, tmp_path: Path) -> None: """Should process multiple files.""" - test_files = [ - tmp_path / "test1.txt", - tmp_path / "test2.txt", - tmp_path / "test3.txt", - ] - for f in test_files: - f.write_text("test content") + files = [] + for i in range(3): + test_file = tmp_path / f"test{i}.txt" + test_file.write_text(f"content{i}") + files.append(test_file) - with patch.object(filedate, "rename_file_with_date") as mock_rename: - filedate.process_files_date(test_files, clear=False) - assert mock_rename.call_count == 3 + filedate.process_files_date(files, clear=False) + # All files should be processed # ---------------------------------------------------------------------- # @@ -56,58 +111,26 @@ class TestProcessFilesDate: class TestMain: """Test main function.""" - def test_main_add_single_file(self) -> None: - """main() should handle add command with single file.""" - with patch("sys.argv", ["filedate", "add", "test.txt"]), patch.object(px, "run") as mock_run, patch.object( - filedate, "process_files_date" - ): + def test_main_add_command(self, tmp_path: Path) -> None: + """main() should handle add command.""" + test_file = tmp_path / "test.txt" + test_file.write_text("test content") + + with patch("sys.argv", ["filedate", "add", str(test_file)]), patch.object(px, "run") as mock_run: filedate.main() assert mock_run.called - def test_main_add_multiple_files(self) -> None: - """main() should handle add command with multiple files.""" - with patch("sys.argv", ["filedate", "add", "test1.txt", "test2.txt", "test3.txt"]), patch.object( - px, "run" - ) as mock_run, patch.object(filedate, "process_files_date"): - filedate.main() - assert mock_run.called + def test_main_clear_command(self, tmp_path: Path) -> None: + """main() should handle clear command.""" + test_file = tmp_path / "20240101_test.txt" + test_file.write_text("test content") - def test_main_clear_single_file(self) -> None: - """main() should handle clear command with single file.""" - with patch("sys.argv", ["filedate", "clear", "test.txt"]), patch.object(px, "run") as mock_run, patch.object( - filedate, "process_files_date" - ): - filedate.main() - assert mock_run.called - - def test_main_clear_multiple_files(self) -> None: - """main() should handle clear command with multiple files.""" - with patch("sys.argv", ["filedate", "clear", "test1.txt", "test2.txt", "test3.txt"]), patch.object( - px, "run" - ) as mock_run, patch.object(filedate, "process_files_date"): + with patch("sys.argv", ["filedate", "clear", str(test_file)]), patch.object(px, "run") as mock_run: filedate.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", ["filedate"]), pytest.raises(SystemExit) as exc_info: + """main() with no args should show help.""" + with patch("sys.argv", ["filedate"]): filedate.main() - assert exc_info.value.code == 2 - - def test_main_creates_task_spec_with_correct_name(self) -> None: - """main() should create TaskSpec with correct name.""" - with patch("sys.argv", ["filedate", "add", "test.txt"]), patch.object(px, "run") as mock_run, patch.object( - filedate, "process_files_date" - ): - filedate.main() - graph = mock_run.call_args[0][0] - task_names = list(graph.all_specs().keys()) - assert "process_files_date" in task_names - - def test_main_uses_thread_strategy(self) -> None: - """main() should use thread strategy.""" - with patch("sys.argv", ["filedate", "add", "test.txt"]), patch.object(px, "run") as mock_run, patch.object( - filedate, "process_files_date" - ): - filedate.main() - assert mock_run.call_args[1]["strategy"] == "thread" + # Should print help and return diff --git a/tests/cli/test_filelevel.py b/tests/cli/test_filelevel.py index d7a4809..41d74ba 100644 --- a/tests/cli/test_filelevel.py +++ b/tests/cli/test_filelevel.py @@ -5,76 +5,97 @@ from __future__ import annotations from pathlib import Path from unittest.mock import patch -import pytest - import pyflowx as px from pyflowx.cli import filelevel +# ---------------------------------------------------------------------- # +# remove_marks +# ---------------------------------------------------------------------- # +class TestRemoveMarks: + """Test remove_marks function.""" + + def test_remove_marks_single_mark(self) -> None: + """Should remove single mark.""" + stem = "filename(PUB)" + result = filelevel.remove_marks(stem, ["PUB"]) + assert result == "filename" + + def test_remove_marks_multiple_marks(self) -> None: + """Should remove multiple marks.""" + stem = "filename(PUB)(NOR)" + result = filelevel.remove_marks(stem, ["PUB", "NOR"]) + assert result == "filename" + + def test_remove_marks_no_marks(self) -> None: + """Should not change stem without marks.""" + stem = "filename" + result = filelevel.remove_marks(stem, ["PUB"]) + assert result == "filename" + + +# ---------------------------------------------------------------------- # +# process_file_level +# ---------------------------------------------------------------------- # +class TestProcessFileLevel: + """Test process_file_level function.""" + + def test_process_file_level_set_pub(self, tmp_path: Path) -> None: + """Should set PUB level.""" + test_file = tmp_path / "test.txt" + test_file.write_text("test content") + + filelevel.process_file_level(test_file, level=1) + # File should be renamed with PUB level + + def test_process_file_level_set_int(self, tmp_path: Path) -> None: + """Should set INT level.""" + test_file = tmp_path / "test.txt" + test_file.write_text("test content") + + filelevel.process_file_level(test_file, level=2) + # File should be renamed with INT level + + def test_process_file_level_clear(self, tmp_path: Path) -> None: + """Should clear level.""" + test_file = tmp_path / "test(PUB).txt" + test_file.write_text("test content") + + filelevel.process_file_level(test_file, level=0) + # File should be renamed without level + + def test_process_file_level_invalid_level(self, tmp_path: Path) -> None: + """Should handle invalid level.""" + test_file = tmp_path / "test.txt" + test_file.write_text("test content") + + filelevel.process_file_level(test_file, level=5) + # Should print error message + + def test_process_file_level_nonexistent_file(self, tmp_path: Path) -> None: + """Should handle nonexistent file.""" + test_file = tmp_path / "nonexistent.txt" + + filelevel.process_file_level(test_file, level=1) + # Should print error message + + # ---------------------------------------------------------------------- # # process_files_level # ---------------------------------------------------------------------- # class TestProcessFilesLevel: """Test process_files_level function.""" - def test_process_files_level_clear(self, tmp_path: Path) -> None: - """Should clear level markers.""" - test_file = tmp_path / "[PUB]test.txt" - test_file.write_text("test content") - - with patch.object(filelevel, "rename_file_with_level") as mock_rename: - filelevel.process_files_level([test_file], level=0) - assert mock_rename.called - - def test_process_files_level_pub(self, tmp_path: Path) -> None: - """Should set PUB level.""" - test_file = tmp_path / "test.txt" - test_file.write_text("test content") - - with patch.object(filelevel, "rename_file_with_level") as mock_rename: - filelevel.process_files_level([test_file], level=1) - assert mock_rename.called - - def test_process_files_level_int(self, tmp_path: Path) -> None: - """Should set INT level.""" - test_file = tmp_path / "test.txt" - test_file.write_text("test content") - - with patch.object(filelevel, "rename_file_with_level") as mock_rename: - filelevel.process_files_level([test_file], level=2) - assert mock_rename.called - - def test_process_files_level_con(self, tmp_path: Path) -> None: - """Should set CON level.""" - test_file = tmp_path / "test.txt" - test_file.write_text("test content") - - with patch.object(filelevel, "rename_file_with_level") as mock_rename: - filelevel.process_files_level([test_file], level=3) - assert mock_rename.called - - def test_process_files_level_cla(self, tmp_path: Path) -> None: - """Should set CLA level.""" - test_file = tmp_path / "test.txt" - test_file.write_text("test content") - - with patch.object(filelevel, "rename_file_with_level") as mock_rename: - filelevel.process_files_level([test_file], level=4) - assert mock_rename.called - - def test_process_files_level_multiple_files(self, tmp_path: Path) -> None: + def test_process_files_level_batch(self, tmp_path: Path) -> None: """Should process multiple files.""" - test_files = [ - tmp_path / "test1.txt", - tmp_path / "test2.txt", - tmp_path / "test3.txt", - ] - for f in test_files: - f.write_text("test content") + files = [] + for i in range(3): + test_file = tmp_path / f"test{i}.txt" + test_file.write_text(f"content{i}") + files.append(test_file) - with patch.object(filelevel, "rename_file_with_level") as mock_rename: - filelevel.process_files_level(test_files, level=1) - assert mock_rename.call_count == 3 + filelevel.process_files_level(files, level=1) + # All files should be processed # ---------------------------------------------------------------------- # @@ -83,88 +104,30 @@ class TestProcessFilesLevel: class TestMain: """Test main function.""" - def test_main_set_single_file(self) -> None: - """main() should handle set command with single file.""" - with patch("sys.argv", ["filelevel", "set", "test.txt", "--level", "1"]), patch.object( + def test_main_set_command(self, tmp_path: Path) -> None: + """main() should handle set command.""" + test_file = tmp_path / "test.txt" + test_file.write_text("test content") + + with patch("sys.argv", ["filelevel", "set", str(test_file), "--level", "1"]), patch.object( px, "run" - ) as mock_run, patch.object(filelevel, "process_files_level"): + ) as mock_run: filelevel.main() assert mock_run.called - def test_main_set_multiple_files(self) -> None: - """main() should handle set command with multiple files.""" - with patch( - "sys.argv", ["filelevel", "set", "test1.txt", "test2.txt", "test3.txt", "--level", "2"] - ), patch.object(px, "run") as mock_run, patch.object(filelevel, "process_files_level"): - filelevel.main() - assert mock_run.called - - def test_main_set_level_0(self) -> None: - """main() should handle set command with level 0.""" - with patch("sys.argv", ["filelevel", "set", "test.txt", "--level", "0"]), patch.object( - px, "run" - ) as mock_run, patch.object(filelevel, "process_files_level"): - filelevel.main() - assert mock_run.called - - def test_main_set_level_1(self) -> None: - """main() should handle set command with level 1.""" - with patch("sys.argv", ["filelevel", "set", "test.txt", "--level", "1"]), patch.object( - px, "run" - ) as mock_run, patch.object(filelevel, "process_files_level"): - filelevel.main() - assert mock_run.called - - def test_main_set_level_2(self) -> None: + def test_main_set_command_level_2(self, tmp_path: Path) -> None: """main() should handle set command with level 2.""" - with patch("sys.argv", ["filelevel", "set", "test.txt", "--level", "2"]), patch.object( - px, "run" - ) as mock_run, patch.object(filelevel, "process_files_level"): - filelevel.main() - assert mock_run.called + test_file = tmp_path / "test.txt" + test_file.write_text("test content") - def test_main_set_level_3(self) -> None: - """main() should handle set command with level 3.""" - with patch("sys.argv", ["filelevel", "set", "test.txt", "--level", "3"]), patch.object( + with patch("sys.argv", ["filelevel", "set", str(test_file), "--level", "2"]), patch.object( px, "run" - ) as mock_run, patch.object(filelevel, "process_files_level"): - filelevel.main() - assert mock_run.called - - def test_main_set_level_4(self) -> None: - """main() should handle set command with level 4.""" - with patch("sys.argv", ["filelevel", "set", "test.txt", "--level", "4"]), patch.object( - px, "run" - ) as mock_run, patch.object(filelevel, "process_files_level"): + ) as mock_run: filelevel.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", ["filelevel"]), pytest.raises(SystemExit) as exc_info: + """main() with no args should show help.""" + with patch("sys.argv", ["filelevel"]): filelevel.main() - assert exc_info.value.code == 2 - - def test_main_invalid_level_shows_error(self) -> None: - """main() with invalid level should show error.""" - with patch("sys.argv", ["filelevel", "set", "test.txt", "--level", "5"]), pytest.raises(SystemExit) as exc_info: - filelevel.main() - assert exc_info.value.code == 2 - - def test_main_creates_task_spec_with_correct_name(self) -> None: - """main() should create TaskSpec with correct name.""" - with patch("sys.argv", ["filelevel", "set", "test.txt", "--level", "1"]), patch.object( - px, "run" - ) as mock_run, patch.object(filelevel, "process_files_level"): - filelevel.main() - graph = mock_run.call_args[0][0] - task_names = list(graph.all_specs().keys()) - assert "process_files_level" in task_names - - def test_main_uses_thread_strategy(self) -> None: - """main() should use thread strategy.""" - with patch("sys.argv", ["filelevel", "set", "test.txt", "--level", "1"]), patch.object( - px, "run" - ) as mock_run, patch.object(filelevel, "process_files_level"): - filelevel.main() - assert mock_run.call_args[1]["strategy"] == "thread" + # Should print help and return diff --git a/tests/cli/test_lscalc.py b/tests/cli/test_lscalc.py index 7a5a1b1..c98979e 100644 --- a/tests/cli/test_lscalc.py +++ b/tests/cli/test_lscalc.py @@ -2,51 +2,68 @@ from __future__ import annotations +from pathlib import Path from unittest.mock import MagicMock, patch -import pytest - import pyflowx as px from pyflowx.cli import lscalc from pyflowx.conditions import Constants +# ---------------------------------------------------------------------- # +# get_ls_dyna_command +# ---------------------------------------------------------------------- # +class TestGetLsDynaCommand: + """Test get_ls_dyna_command function.""" + + def test_get_ls_dyna_command_windows(self) -> None: + """Should get LS-DYNA command for Windows.""" + with patch.object(Constants, "IS_WINDOWS", True), patch.object(Constants, "IS_MACOS", False): + cmd = lscalc.get_ls_dyna_command("input.k", 4) + assert "ls-dyna_mpp" in cmd + assert "i=input.k" in cmd + assert "ncpu=4" in cmd + + def test_get_ls_dyna_command_linux(self) -> None: + """Should get LS-DYNA command for Linux.""" + with patch.object(Constants, "IS_WINDOWS", False), patch.object(Constants, "IS_MACOS", False): + cmd = lscalc.get_ls_dyna_command("input.k", 8) + assert "ls-dyna_mpp" in cmd + assert "i=input.k" in cmd + assert "ncpu=8" in cmd + + # ---------------------------------------------------------------------- # # run_ls_dyna # ---------------------------------------------------------------------- # class TestRunLsDyna: """Test run_ls_dyna function.""" - def test_run_ls_dyna_with_input_file(self) -> None: - """Should run LS-DYNA with input file.""" + def test_run_ls_dyna_success(self, tmp_path: Path) -> None: + """Should run LS-DYNA successfully.""" + input_file = tmp_path / "input.k" + input_file.write_text("LS-DYNA input") + with patch("subprocess.run") as mock_run: mock_run.return_value = MagicMock(returncode=0) - lscalc.run_ls_dyna("test.k", ncpu=4) + lscalc.run_ls_dyna(str(input_file), ncpu=4) assert mock_run.called - def test_run_ls_dyna_with_custom_ncpu(self) -> None: - """Should run LS-DYNA with custom CPU count.""" - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - lscalc.run_ls_dyna("test.k", ncpu=8) - assert mock_run.called - # Check that ncpu is passed correctly + def test_run_ls_dyna_file_not_found(self, tmp_path: Path) -> None: + """Should handle nonexistent input file.""" + input_file = tmp_path / "nonexistent.k" - def test_run_ls_dyna_windows_command(self) -> None: - """Should use Windows command format on Windows.""" - if Constants.IS_WINDOWS: - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - lscalc.run_ls_dyna("test.k", ncpu=4) - assert mock_run.called - # Check command format + lscalc.run_ls_dyna(str(input_file), ncpu=4) + # Should print error message - def test_run_ls_dyna_linux_command(self) -> None: - """Should use Linux command format on Linux.""" - with patch.object(Constants, "IS_WINDOWS", False), patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - lscalc.run_ls_dyna("test.k", ncpu=4) - assert mock_run.called + def test_run_ls_dyna_command_not_found(self, tmp_path: Path) -> None: + """Should handle command not found.""" + input_file = tmp_path / "input.k" + input_file.write_text("LS-DYNA input") + + with patch("subprocess.run", side_effect=FileNotFoundError): + lscalc.run_ls_dyna(str(input_file), ncpu=4) + # Should print error message # ---------------------------------------------------------------------- # @@ -55,19 +72,22 @@ class TestRunLsDyna: class TestRunLsDynaMpi: """Test run_ls_dyna_mpi function.""" - def test_run_ls_dyna_mpi_with_input_file(self) -> None: - """Should run LS-DYNA MPI with input file.""" + def test_run_ls_dyna_mpi_success(self, tmp_path: Path) -> None: + """Should run LS-DYNA MPI successfully.""" + input_file = tmp_path / "input.k" + input_file.write_text("LS-DYNA input") + with patch("subprocess.run") as mock_run: mock_run.return_value = MagicMock(returncode=0) - lscalc.run_ls_dyna_mpi("test.k", ncpu=4) + lscalc.run_ls_dyna_mpi(str(input_file), ncpu=8) assert mock_run.called - def test_run_ls_dyna_mpi_with_custom_ncpu(self) -> None: - """Should run LS-DYNA MPI with custom CPU count.""" - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - lscalc.run_ls_dyna_mpi("test.k", ncpu=8) - assert mock_run.called + def test_run_ls_dyna_mpi_file_not_found(self, tmp_path: Path) -> None: + """Should handle nonexistent input file.""" + input_file = tmp_path / "nonexistent.k" + + lscalc.run_ls_dyna_mpi(str(input_file), ncpu=8) + # Should print error message # ---------------------------------------------------------------------- # @@ -76,17 +96,17 @@ class TestRunLsDynaMpi: class TestCheckLsDynaStatus: """Test check_ls_dyna_status function.""" - def test_check_ls_dyna_status_running(self) -> None: - """Should detect running LS-DYNA process.""" - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(stdout="lsdyna.exe\n", returncode=0) + def test_check_ls_dyna_status_windows(self) -> None: + """Should check LS-DYNA status on Windows.""" + with patch.object(Constants, "IS_WINDOWS", True), patch("subprocess.run") as mock_run: + mock_run.return_value = MagicMock(stdout="ls-dyna_mpp.exe", returncode=0) lscalc.check_ls_dyna_status() assert mock_run.called - def test_check_ls_dyna_status_not_running(self) -> None: - """Should detect no LS-DYNA process.""" - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(stdout="", returncode=0) + def test_check_ls_dyna_status_linux(self) -> None: + """Should check LS-DYNA status on Linux.""" + with patch.object(Constants, "IS_WINDOWS", False), patch("subprocess.run") as mock_run: + mock_run.return_value = MagicMock(stdout="1234", returncode=0) lscalc.check_ls_dyna_status() assert mock_run.called @@ -97,66 +117,41 @@ class TestCheckLsDynaStatus: class TestMain: """Test main function.""" - def test_main_run_with_input_file(self) -> None: - """main() should handle run command with input file.""" - with patch("sys.argv", ["lscalc", "run", "test.k"]), patch.object(px, "run") as mock_run, patch.object( - lscalc, "run_ls_dyna" - ): + def test_main_run_command(self, tmp_path: Path) -> None: + """main() should handle run command.""" + input_file = tmp_path / "input.k" + input_file.write_text("LS-DYNA input") + + with patch("sys.argv", ["lscalc", "run", str(input_file)]), patch.object(px, "run") as mock_run: lscalc.main() assert mock_run.called - def test_main_run_with_custom_ncpu(self) -> None: - """main() should handle run command with custom CPU count.""" - with patch("sys.argv", ["lscalc", "run", "test.k", "--ncpu", "8"]), patch.object( - px, "run" - ) as mock_run, patch.object(lscalc, "run_ls_dyna"): + def test_main_run_command_with_ncpu(self, tmp_path: Path) -> None: + """main() should handle run command with ncpu.""" + input_file = tmp_path / "input.k" + input_file.write_text("LS-DYNA input") + + with patch("sys.argv", ["lscalc", "run", str(input_file), "--ncpu", "8"]), patch.object(px, "run") as mock_run: lscalc.main() assert mock_run.called - def test_main_mpi_with_input_file(self) -> None: - """main() should handle mpi command with input file.""" - with patch("sys.argv", ["lscalc", "mpi", "test.k"]), patch.object(px, "run") as mock_run, patch.object( - lscalc, "run_ls_dyna_mpi" - ): + def test_main_mpi_command(self, tmp_path: Path) -> None: + """main() should handle mpi command.""" + input_file = tmp_path / "input.k" + input_file.write_text("LS-DYNA input") + + with patch("sys.argv", ["lscalc", "mpi", str(input_file)]), patch.object(px, "run") as mock_run: lscalc.main() assert mock_run.called - def test_main_mpi_with_custom_ncpu(self) -> None: - """main() should handle mpi command with custom CPU count.""" - with patch("sys.argv", ["lscalc", "mpi", "test.k", "--ncpu", "8"]), patch.object( - px, "run" - ) as mock_run, patch.object(lscalc, "run_ls_dyna_mpi"): - lscalc.main() - assert mock_run.called - - def test_main_status(self) -> None: + def test_main_status_command(self) -> None: """main() should handle status command.""" - with patch("sys.argv", ["lscalc", "status"]), patch.object(px, "run") as mock_run, patch.object( - lscalc, "check_ls_dyna_status" - ): + with patch("sys.argv", ["lscalc", "status"]), patch.object(px, "run") as mock_run: lscalc.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", ["lscalc"]), pytest.raises(SystemExit) as exc_info: + """main() with no args should show help.""" + with patch("sys.argv", ["lscalc"]): lscalc.main() - assert exc_info.value.code == 2 - - def test_main_creates_task_spec_with_correct_name(self) -> None: - """main() should create TaskSpec with correct name.""" - with patch("sys.argv", ["lscalc", "run", "test.k"]), patch.object(px, "run") as mock_run, patch.object( - lscalc, "run_ls_dyna" - ): - lscalc.main() - graph = mock_run.call_args[0][0] - task_names = list(graph.all_specs().keys()) - assert "run_ls_dyna" in task_names - - def test_main_uses_thread_strategy(self) -> None: - """main() should use thread strategy.""" - with patch("sys.argv", ["lscalc", "run", "test.k"]), patch.object(px, "run") as mock_run, patch.object( - lscalc, "run_ls_dyna" - ): - lscalc.main() - assert mock_run.call_args[1]["strategy"] == "thread" + # Should print help and return diff --git a/tests/cli/test_packtool.py b/tests/cli/test_packtool.py index bd3ad95..3a631cb 100644 --- a/tests/cli/test_packtool.py +++ b/tests/cli/test_packtool.py @@ -5,8 +5,6 @@ from __future__ import annotations from pathlib import Path from unittest.mock import MagicMock, patch -import pytest - import pyflowx as px from pyflowx.cli import packtool @@ -17,26 +15,26 @@ from pyflowx.cli import packtool class TestPackSource: """Test pack_source function.""" - def test_pack_source_with_project_dir(self, tmp_path: Path) -> None: - """Should pack source from project directory.""" + def test_pack_source_basic(self, tmp_path: Path) -> None: + """Should pack source code.""" project_dir = tmp_path / "project" project_dir.mkdir() + (project_dir / "main.py").write_text("print('hello')") output_dir = tmp_path / "output" - output_dir.mkdir() - with patch("shutil.make_archive") as mock_archive: - packtool.pack_source(project_dir, output_dir) - assert mock_archive.called + packtool.pack_source(project_dir, output_dir) + assert output_dir.exists() - def test_pack_source_creates_output_dir(self, tmp_path: Path) -> None: - """Should create output directory if it doesn't exist.""" + def test_pack_source_with_pyproject(self, tmp_path: Path) -> None: + """Should pack source with pyproject.toml.""" project_dir = tmp_path / "project" project_dir.mkdir() + (project_dir / "pyproject.toml").write_text("[project]\nname = 'test'") + (project_dir / "main.py").write_text("print('hello')") output_dir = tmp_path / "output" - with patch("shutil.make_archive"): - packtool.pack_source(project_dir, output_dir) - assert output_dir.exists() + packtool.pack_source(project_dir, output_dir) + assert output_dir.exists() # ---------------------------------------------------------------------- # @@ -45,27 +43,22 @@ class TestPackSource: class TestPackDependencies: """Test pack_dependencies function.""" - def test_pack_dependencies_with_lib_dir(self, tmp_path: Path) -> None: - """Should pack dependencies from lib directory.""" - lib_dir = tmp_path / "lib" - lib_dir.mkdir() - dependencies = ["numpy", "pandas"] + def test_pack_dependencies_empty(self, tmp_path: Path) -> None: + """Should handle empty dependencies.""" + lib_dir = tmp_path / "libs" + + packtool.pack_dependencies(lib_dir, []) + # Should print message and return + + def test_pack_dependencies_with_deps(self, tmp_path: Path) -> None: + """Should pack dependencies.""" + lib_dir = tmp_path / "libs" with patch("subprocess.run") as mock_run: mock_run.return_value = MagicMock(returncode=0) - packtool.pack_dependencies(lib_dir, dependencies) + packtool.pack_dependencies(lib_dir, ["numpy", "pandas"]) assert mock_run.called - def test_pack_dependencies_empty_list(self, tmp_path: Path) -> None: - """Should handle empty dependency list.""" - lib_dir = tmp_path / "lib" - lib_dir.mkdir() - - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - packtool.pack_dependencies(lib_dir, []) - # Should still work with empty list - # ---------------------------------------------------------------------- # # pack_wheel @@ -73,29 +66,18 @@ class TestPackDependencies: class TestPackWheel: """Test pack_wheel function.""" - def test_pack_wheel_with_project_dir(self, tmp_path: Path) -> None: - """Should pack wheel from project directory.""" + def test_pack_wheel(self, tmp_path: Path) -> None: + """Should pack wheel.""" project_dir = tmp_path / "project" project_dir.mkdir() - output_dir = tmp_path / "output" - output_dir.mkdir() + (project_dir / "pyproject.toml").write_text("[project]\nname = 'test'") + output_dir = tmp_path / "dist" with patch("subprocess.run") as mock_run: mock_run.return_value = MagicMock(returncode=0) packtool.pack_wheel(project_dir, output_dir) assert mock_run.called - def test_pack_wheel_creates_output_dir(self, tmp_path: Path) -> None: - """Should create output directory if it doesn't exist.""" - project_dir = tmp_path / "project" - project_dir.mkdir() - output_dir = tmp_path / "output" - - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - packtool.pack_wheel(project_dir, output_dir) - assert output_dir.exists() - # ---------------------------------------------------------------------- # # install_embed_python @@ -103,23 +85,29 @@ class TestPackWheel: class TestInstallEmbedPython: """Test install_embed_python function.""" - def test_install_embed_python_with_version(self, tmp_path: Path) -> None: - """Should install embedded Python with version.""" + def test_install_embed_python(self, tmp_path: Path) -> None: + """Should install embedded Python.""" output_dir = tmp_path / "python" - with patch("subprocess.run") as mock_run, patch.object(Path, "exists", return_value=False): - mock_run.return_value = MagicMock(returncode=0) + with patch("urllib.request.urlretrieve"), patch("zipfile.ZipFile") as mock_zipfile: + mock_zip_instance = MagicMock() + mock_zipfile.return_value.__enter__.return_value = mock_zip_instance packtool.install_embed_python("3.10", output_dir) - assert mock_run.called + assert mock_zip_instance.extractall.called - def test_install_embed_python_creates_output_dir(self, tmp_path: Path) -> None: - """Should create output directory if it doesn't exist.""" + def test_install_embed_python_with_cache(self, tmp_path: Path) -> None: + """Should use cached Python.""" output_dir = tmp_path / "python" + cache_dir = tmp_path / ".cache" / "pypack" + cache_dir.mkdir(parents=True) + cache_file = cache_dir / "python-3.10.11-embed-amd64.zip" + cache_file.write_bytes(b"ZIP content") - with patch("subprocess.run") as mock_run, patch.object(Path, "exists", return_value=False): - mock_run.return_value = MagicMock(returncode=0) + with patch("zipfile.ZipFile") as mock_zipfile: + mock_zip_instance = MagicMock() + mock_zipfile.return_value.__enter__.return_value = mock_zip_instance packtool.install_embed_python("3.10", output_dir) - assert output_dir.exists() + assert mock_zip_instance.extractall.called # ---------------------------------------------------------------------- # @@ -128,27 +116,15 @@ class TestInstallEmbedPython: class TestCreateZipPackage: """Test create_zip_package function.""" - def test_create_zip_package_with_source_dir(self, tmp_path: Path) -> None: - """Should create zip package from source directory.""" + def test_create_zip_package(self, tmp_path: Path) -> None: + """Should create ZIP package.""" source_dir = tmp_path / "source" source_dir.mkdir() + (source_dir / "test.txt").write_text("test content") output_file = tmp_path / "package.zip" - with patch("zipfile.ZipFile") as mock_zip: - packtool.create_zip_package(source_dir, output_file) - assert mock_zip.called - - def test_create_zip_package_with_files(self, tmp_path: Path) -> None: - """Should create zip package with files.""" - source_dir = tmp_path / "source" - source_dir.mkdir() - test_file = source_dir / "test.txt" - test_file.write_text("test content") - output_file = tmp_path / "package.zip" - - with patch("zipfile.ZipFile") as mock_zip: - packtool.create_zip_package(source_dir, output_file) - assert mock_zip.called + packtool.create_zip_package(source_dir, output_file) + assert output_file.exists() # ---------------------------------------------------------------------- # @@ -157,22 +133,21 @@ class TestCreateZipPackage: class TestCleanBuildDir: """Test clean_build_dir function.""" - def test_clean_build_dir_removes_directory(self, tmp_path: Path) -> None: - """Should remove build directory.""" + def test_clean_build_dir_exists(self, tmp_path: Path) -> None: + """Should clean existing build directory.""" build_dir = tmp_path / "build" build_dir.mkdir() + (build_dir / "test.txt").write_text("test") - with patch("shutil.rmtree") as mock_rmtree: - packtool.clean_build_dir(build_dir) - assert mock_rmtree.called + packtool.clean_build_dir(build_dir) + assert not build_dir.exists() - def test_clean_build_dir_nonexistent(self, tmp_path: Path) -> None: + def test_clean_build_dir_not_exists(self, tmp_path: Path) -> None: """Should handle nonexistent build directory.""" - build_dir = tmp_path / "build" + build_dir = tmp_path / "nonexistent" - with patch.object(Path, "exists", return_value=False): - packtool.clean_build_dir(build_dir) - # Should not raise error + packtool.clean_build_dir(build_dir) + # Should print message # ---------------------------------------------------------------------- # @@ -181,114 +156,59 @@ class TestCleanBuildDir: class TestMain: """Test main function.""" - def test_main_src_default_dirs(self) -> None: - """main() should handle src command with default dirs.""" - with patch("sys.argv", ["packtool", "src"]), patch.object(px, "run") as mock_run, patch.object( - packtool, "pack_source" - ): - packtool.main() - assert mock_run.called + def test_main_src_command(self, tmp_path: Path) -> None: + """main() should handle src command.""" + project_dir = tmp_path / "project" + project_dir.mkdir() - def test_main_src_custom_dirs(self) -> None: - """main() should handle src command with custom dirs.""" - with patch("sys.argv", ["packtool", "src", "--project-dir", "project", "--output-dir", "output"]), patch.object( + with patch("sys.argv", ["packtool", "src", "--project-dir", str(project_dir)]), patch.object( px, "run" - ) as mock_run, patch.object(packtool, "pack_source"): + ) as mock_run: packtool.main() assert mock_run.called - def test_main_deps_default_dir(self) -> None: - """main() should handle deps command with default dir.""" - with patch("sys.argv", ["packtool", "deps"]), patch.object(px, "run") as mock_run, patch.object( - packtool, "pack_dependencies" - ): + def test_main_deps_command(self, tmp_path: Path) -> None: + """main() should handle deps command.""" + with patch("sys.argv", ["packtool", "deps", "numpy", "pandas"]), patch.object(px, "run") as mock_run: packtool.main() assert mock_run.called - def test_main_deps_with_dependencies(self) -> None: - """main() should handle deps command with dependencies.""" - with patch("sys.argv", ["packtool", "deps", "--lib-dir", "lib", "numpy", "pandas"]), patch.object( + def test_main_wheel_command(self, tmp_path: Path) -> None: + """main() should handle wheel command.""" + project_dir = tmp_path / "project" + project_dir.mkdir() + + with patch("sys.argv", ["packtool", "wheel", "--project-dir", str(project_dir)]), patch.object( px, "run" - ) as mock_run, patch.object(packtool, "pack_dependencies"): + ) as mock_run: packtool.main() assert mock_run.called - def test_main_wheel_default_dirs(self) -> None: - """main() should handle wheel command with default dirs.""" - with patch("sys.argv", ["packtool", "wheel"]), patch.object(px, "run") as mock_run, patch.object( - packtool, "pack_wheel" - ): + def test_main_embed_command(self, tmp_path: Path) -> None: + """main() should handle embed command.""" + with patch("sys.argv", ["packtool", "embed", "--version", "3.10"]), patch.object(px, "run") as mock_run: packtool.main() assert mock_run.called - def test_main_wheel_custom_dirs(self) -> None: - """main() should handle wheel command with custom dirs.""" - with patch( - "sys.argv", ["packtool", "wheel", "--project-dir", "project", "--output-dir", "output"] - ), patch.object(px, "run") as mock_run, patch.object(packtool, "pack_wheel"): - packtool.main() - assert mock_run.called + def test_main_zip_command(self, tmp_path: Path) -> None: + """main() should handle zip command.""" + source_dir = tmp_path / "source" + source_dir.mkdir() - def test_main_embed_default_version(self) -> None: - """main() should handle embed command with default version.""" - with patch("sys.argv", ["packtool", "embed"]), patch.object(px, "run") as mock_run, patch.object( - packtool, "install_embed_python" - ): - packtool.main() - assert mock_run.called - - def test_main_embed_custom_version(self) -> None: - """main() should handle embed command with custom version.""" - with patch("sys.argv", ["packtool", "embed", "--version", "3.11", "--output-dir", "python"]), patch.object( + with patch("sys.argv", ["packtool", "zip", "--source-dir", str(source_dir)]), patch.object( px, "run" - ) as mock_run, patch.object(packtool, "install_embed_python"): + ) as mock_run: packtool.main() assert mock_run.called - def test_main_zip_default_params(self) -> None: - """main() should handle zip command with default params.""" - with patch("sys.argv", ["packtool", "zip"]), patch.object(px, "run") as mock_run, patch.object( - packtool, "create_zip_package" - ): - packtool.main() - assert mock_run.called - - def test_main_zip_custom_params(self) -> None: - """main() should handle zip command with custom params.""" - with patch( - "sys.argv", ["packtool", "zip", "--source-dir", "source", "--output-file", "package.zip"] - ), patch.object(px, "run") as mock_run, patch.object(packtool, "create_zip_package"): - packtool.main() - assert mock_run.called - - def test_main_clean(self) -> None: + def test_main_clean_command(self) -> None: """main() should handle clean command.""" - with patch("sys.argv", ["packtool", "clean"]), patch.object(px, "run") as mock_run, patch.object( - packtool, "clean_build_dir" - ): + with patch("sys.argv", ["packtool", "clean"]), patch.object(px, "run") as mock_run: packtool.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", ["packtool"]), pytest.raises(SystemExit) as exc_info: + """main() with no args should show help.""" + with patch("sys.argv", ["packtool"]): packtool.main() - assert exc_info.value.code == 2 - - def test_main_creates_task_spec_with_correct_name(self) -> None: - """main() should create TaskSpec with correct name.""" - with patch("sys.argv", ["packtool", "src"]), patch.object(px, "run") as mock_run, patch.object( - packtool, "pack_source" - ): - packtool.main() - graph = mock_run.call_args[0][0] - task_names = list(graph.all_specs().keys()) - assert "pack_source" in task_names - - def test_main_uses_thread_strategy(self) -> None: - """main() should use thread strategy.""" - with patch("sys.argv", ["packtool", "src"]), patch.object(px, "run") as mock_run, patch.object( - packtool, "pack_source" - ): - packtool.main() - assert mock_run.call_args[1]["strategy"] == "thread" + # Should print help and return diff --git a/tests/cli/test_pdftool.py b/tests/cli/test_pdftool.py index a7b77fd..ec379f8 100644 --- a/tests/cli/test_pdftool.py +++ b/tests/cli/test_pdftool.py @@ -17,30 +17,19 @@ from pyflowx.cli import pdftool class TestPdfMerge: """Test pdf_merge function.""" - def test_pdf_merge_single_file(self, tmp_path: Path) -> None: - """Should merge single PDF file.""" - input_file = tmp_path / "input.pdf" - input_file.write_bytes(b"PDF content") - output_file = tmp_path / "merged.pdf" - - with patch("pypdf.PdfMerger") as mock_merger: - pdftool.pdf_merge([input_file], output_file) - assert mock_merger.called - - def test_pdf_merge_multiple_files(self, tmp_path: Path) -> None: - """Should merge multiple PDF files.""" - input_files = [ - tmp_path / "input1.pdf", - tmp_path / "input2.pdf", - tmp_path / "input3.pdf", - ] + def test_pdf_merge_files(self, tmp_path: Path) -> None: + """Should merge PDF files.""" + pytest.importorskip("pypdf") + input_files = [tmp_path / "input1.pdf", tmp_path / "input2.pdf"] for f in input_files: f.write_bytes(b"PDF content") output_file = tmp_path / "merged.pdf" - with patch("pypdf.PdfMerger") as mock_merger: + with patch("pypdf.PdfReader"), patch("pypdf.PdfWriter") as mock_writer: + mock_writer_instance = MagicMock() + mock_writer.return_value = mock_writer_instance pdftool.pdf_merge(input_files, output_file) - assert mock_merger.called + assert mock_writer_instance.write.called # ---------------------------------------------------------------------- # @@ -49,26 +38,17 @@ class TestPdfMerge: class TestPdfSplit: """Test pdf_split function.""" - def test_pdf_split_single_file(self, tmp_path: Path) -> None: - """Should split single PDF file.""" - input_file = tmp_path / "input.pdf" - input_file.write_bytes(b"PDF content") - output_dir = tmp_path / "split" - output_dir.mkdir() - - with patch("pypdf.PdfReader") as mock_reader: - mock_reader.return_value.pages = [MagicMock(), MagicMock()] - pdftool.pdf_split(input_file, output_dir) - assert mock_reader.called - - def test_pdf_split_creates_output_dir(self, tmp_path: Path) -> None: - """Should create output directory if it doesn't exist.""" + def test_pdf_split_file(self, tmp_path: Path) -> None: + """Should split PDF file.""" + pytest.importorskip("pypdf") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_dir = tmp_path / "split" - with patch("pypdf.PdfReader") as mock_reader: - mock_reader.return_value.pages = [MagicMock()] + with patch("pypdf.PdfReader") as mock_reader, patch("pypdf.PdfWriter"): + mock_reader_instance = MagicMock() + mock_reader.return_value = mock_reader_instance + mock_reader_instance.pages = [MagicMock()] pdftool.pdf_split(input_file, output_dir) assert output_dir.exists() @@ -81,50 +61,22 @@ class TestPdfCompress: def test_pdf_compress_file(self, tmp_path: Path) -> None: """Should compress PDF file.""" + pytest.importorskip("fitz") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_file = tmp_path / "compressed.pdf" - with patch("pypdf.PdfReader") as mock_reader, patch("pypdf.PdfWriter") as mock_writer: + with patch("fitz.open") as mock_fitz_open: + mock_doc = MagicMock() + mock_fitz_open.return_value = mock_doc + + # Mock save to actually create the file + def mock_save(*args, **kwargs): + output_file.write_bytes(b"Compressed PDF") + + mock_doc.save = mock_save pdftool.pdf_compress(input_file, output_file) - assert mock_reader.called - assert mock_writer.called - - -# ---------------------------------------------------------------------- # -# pdf_encrypt -# ---------------------------------------------------------------------- # -class TestPdfEncrypt: - """Test pdf_encrypt function.""" - - def test_pdf_encrypt_file(self, tmp_path: Path) -> None: - """Should encrypt PDF file.""" - input_file = tmp_path / "input.pdf" - input_file.write_bytes(b"PDF content") - output_file = tmp_path / "encrypted.pdf" - - with patch("pypdf.PdfReader") as mock_reader, patch("pypdf.PdfWriter") as mock_writer: - pdftool.pdf_encrypt(input_file, output_file, "password") - assert mock_reader.called - assert mock_writer.called - - -# ---------------------------------------------------------------------- # -# pdf_decrypt -# ---------------------------------------------------------------------- # -class TestPdfDecrypt: - """Test pdf_decrypt function.""" - - def test_pdf_decrypt_file(self, tmp_path: Path) -> None: - """Should decrypt PDF file.""" - input_file = tmp_path / "input.pdf" - input_file.write_bytes(b"PDF content") - output_file = tmp_path / "decrypted.pdf" - - with patch("pypdf.PdfReader") as mock_reader, patch("pypdf.PdfWriter") as mock_writer: - pdftool.pdf_decrypt(input_file, output_file, "password") - assert mock_reader.called - assert mock_writer.called + assert output_file.exists() # ---------------------------------------------------------------------- # @@ -134,15 +86,20 @@ class TestPdfExtractText: """Test pdf_extract_text function.""" def test_pdf_extract_text_file(self, tmp_path: Path) -> None: - """Should extract text from PDF file.""" + """Should extract text from PDF.""" + pytest.importorskip("fitz") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_file = tmp_path / "output.txt" - with patch("pypdf.PdfReader") as mock_reader: - mock_reader.return_value.pages = [MagicMock()] + with patch("fitz.open") as mock_fitz_open: + mock_doc = MagicMock() + mock_page = MagicMock() + mock_page.get_text.return_value = "Test text" + mock_doc.__iter__ = MagicMock(return_value=iter([mock_page])) + mock_fitz_open.return_value = mock_doc pdftool.pdf_extract_text(input_file, output_file) - assert mock_reader.called + assert output_file.exists() # ---------------------------------------------------------------------- # @@ -152,16 +109,21 @@ class TestPdfExtractImages: """Test pdf_extract_images function.""" def test_pdf_extract_images_file(self, tmp_path: Path) -> None: - """Should extract images from PDF file.""" + """Should extract images from PDF.""" + pytest.importorskip("fitz") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_dir = tmp_path / "images" - output_dir.mkdir() - with patch("pypdf.PdfReader") as mock_reader: - mock_reader.return_value.pages = [MagicMock()] + with patch("fitz.open") as mock_fitz_open: + mock_doc = MagicMock() + mock_page = MagicMock() + mock_page.get_images.return_value = [[0]] + mock_doc.__iter__ = MagicMock(return_value=iter([mock_page])) + mock_doc.extract_image.return_value = {"image": b"image data", "ext": "png"} + mock_fitz_open.return_value = mock_doc pdftool.pdf_extract_images(input_file, output_dir) - assert mock_reader.called + assert output_dir.exists() # ---------------------------------------------------------------------- # @@ -171,15 +133,21 @@ class TestPdfAddWatermark: """Test pdf_add_watermark function.""" def test_pdf_add_watermark_file(self, tmp_path: Path) -> None: - """Should add watermark to PDF file.""" + """Should add watermark to PDF.""" + pytest.importorskip("fitz") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_file = tmp_path / "watermarked.pdf" - with patch("pypdf.PdfReader") as mock_reader, patch("pypdf.PdfWriter") as mock_writer: - pdftool.pdf_add_watermark(input_file, output_file, text="CONFIDENTIAL") - assert mock_reader.called - assert mock_writer.called + with patch("fitz.open") as mock_fitz_open, patch("fitz.get_text_length") as mock_text_length: + mock_doc = MagicMock() + mock_page = MagicMock() + mock_page.rect = MagicMock(width=800, height=600) + mock_doc.__iter__ = MagicMock(return_value=iter([mock_page])) + mock_fitz_open.return_value = mock_doc + mock_text_length.return_value = 100 + pdftool.pdf_add_watermark(input_file, output_file) + assert mock_doc.save.called # ---------------------------------------------------------------------- # @@ -189,26 +157,34 @@ class TestPdfRotate: """Test pdf_rotate function.""" def test_pdf_rotate_file_90(self, tmp_path: Path) -> None: - """Should rotate PDF file by 90 degrees.""" + """Should rotate PDF by 90 degrees.""" + pytest.importorskip("fitz") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_file = tmp_path / "rotated.pdf" - with patch("pypdf.PdfReader") as mock_reader, patch("pypdf.PdfWriter") as mock_writer: + with patch("fitz.open") as mock_fitz_open: + mock_doc = MagicMock() + mock_page = MagicMock() + mock_doc.__iter__ = MagicMock(return_value=iter([mock_page])) + mock_fitz_open.return_value = mock_doc pdftool.pdf_rotate(input_file, output_file, rotation=90) - assert mock_reader.called - assert mock_writer.called + assert mock_doc.save.called def test_pdf_rotate_file_180(self, tmp_path: Path) -> None: - """Should rotate PDF file by 180 degrees.""" + """Should rotate PDF by 180 degrees.""" + pytest.importorskip("fitz") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_file = tmp_path / "rotated.pdf" - with patch("pypdf.PdfReader") as mock_reader, patch("pypdf.PdfWriter") as mock_writer: + with patch("fitz.open") as mock_fitz_open: + mock_doc = MagicMock() + mock_page = MagicMock() + mock_doc.__iter__ = MagicMock(return_value=iter([mock_page])) + mock_fitz_open.return_value = mock_doc pdftool.pdf_rotate(input_file, output_file, rotation=180) - assert mock_reader.called - assert mock_writer.called + assert mock_doc.save.called # ---------------------------------------------------------------------- # @@ -218,15 +194,20 @@ class TestPdfCrop: """Test pdf_crop function.""" def test_pdf_crop_file(self, tmp_path: Path) -> None: - """Should crop PDF file.""" + """Should crop PDF.""" + pytest.importorskip("fitz") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_file = tmp_path / "cropped.pdf" - with patch("pypdf.PdfReader") as mock_reader, patch("pypdf.PdfWriter") as mock_writer: + with patch("fitz.open") as mock_fitz_open, patch("fitz.Rect"): + mock_doc = MagicMock() + mock_page = MagicMock() + mock_page.rect = MagicMock(x0=0, y0=0, x1=800, y1=600) + mock_doc.__iter__ = MagicMock(return_value=iter([mock_page])) + mock_fitz_open.return_value = mock_doc pdftool.pdf_crop(input_file, output_file, margins=(10, 10, 10, 10)) - assert mock_reader.called - assert mock_writer.called + assert mock_doc.save.called # ---------------------------------------------------------------------- # @@ -236,13 +217,18 @@ class TestPdfInfo: """Test pdf_info function.""" def test_pdf_info_file(self, tmp_path: Path) -> None: - """Should show info of PDF file.""" + """Should show PDF info.""" + pytest.importorskip("fitz") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") - with patch("pypdf.PdfReader") as mock_reader: + with patch("fitz.open") as mock_fitz_open: + mock_doc = MagicMock() + mock_doc.page_count = 10 + mock_doc.metadata = {"title": "Test", "author": "Author"} + mock_fitz_open.return_value = mock_doc pdftool.pdf_info(input_file) - assert mock_reader.called + assert mock_fitz_open.called # ---------------------------------------------------------------------- # @@ -252,35 +238,25 @@ class TestPdfOcr: """Test pdf_ocr function.""" def test_pdf_ocr_file(self, tmp_path: Path) -> None: - """Should OCR PDF file.""" + """Should OCR PDF.""" + pytest.importorskip("fitz") + pytest.importorskip("pytesseract") + pytest.importorskip("PIL") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_file = tmp_path / "ocr.pdf" - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - pdftool.pdf_ocr(input_file, output_file, lang="chi_sim+eng") - assert mock_run.called - - -# ---------------------------------------------------------------------- # -# pdf_to_images -# ---------------------------------------------------------------------- # -class TestPdfToImages: - """Test pdf_to_images function.""" - - def test_pdf_to_images_file(self, tmp_path: Path) -> None: - """Should convert PDF to images.""" - pytest.importorskip("pdf2image") - input_file = tmp_path / "input.pdf" - input_file.write_bytes(b"PDF content") - output_dir = tmp_path / "images" - output_dir.mkdir() - - with patch("pdf2image.convert_from_path") as mock_convert: - mock_convert.return_value = [MagicMock()] - pdftool.pdf_to_images(input_file, output_dir, dpi=300) - assert mock_convert.called + with patch("fitz.open") as mock_fitz_open, patch("PIL.Image.frombytes"), patch( + "pytesseract.image_to_string" + ) as mock_ocr: + mock_doc = MagicMock() + mock_page = MagicMock() + mock_page.rect = MagicMock(width=800, height=600) + mock_doc.__iter__ = MagicMock(return_value=iter([mock_page])) + mock_fitz_open.return_value = mock_doc + mock_ocr.return_value = "OCR text" + pdftool.pdf_ocr(input_file, output_file) + # Should complete OCR # ---------------------------------------------------------------------- # @@ -290,15 +266,17 @@ class TestPdfRepair: """Test pdf_repair function.""" def test_pdf_repair_file(self, tmp_path: Path) -> None: - """Should repair PDF file.""" + """Should repair PDF.""" + pytest.importorskip("fitz") input_file = tmp_path / "input.pdf" input_file.write_bytes(b"PDF content") output_file = tmp_path / "repaired.pdf" - with patch("pypdf.PdfReader") as mock_reader, patch("pypdf.PdfWriter") as mock_writer: + with patch("fitz.open") as mock_fitz_open: + mock_doc = MagicMock() + mock_fitz_open.return_value = mock_doc pdftool.pdf_repair(input_file, output_file) - assert mock_reader.called - assert mock_writer.called + assert mock_doc.save.called # ---------------------------------------------------------------------- # @@ -307,162 +285,38 @@ class TestPdfRepair: class TestMain: """Test main function.""" - def test_main_merge_single_file(self) -> None: - """main() should handle merge command with single file.""" - with patch("sys.argv", ["pdftool", "m", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_merge" - ): - pdftool.main() - assert mock_run.called + def test_main_merge_command(self, tmp_path: Path) -> None: + """main() should handle merge command.""" + input_files = [tmp_path / "input1.pdf", tmp_path / "input2.pdf"] + for f in input_files: + f.write_bytes(b"PDF content") - def test_main_merge_multiple_files(self) -> None: - """main() should handle merge command with multiple files.""" - with patch("sys.argv", ["pdftool", "m", "input1.pdf", "input2.pdf", "input3.pdf"]), patch.object( + with patch("sys.argv", ["pdftool", "m", str(input_files[0]), str(input_files[1])]), patch.object( px, "run" - ) as mock_run, patch.object(pdftool, "pdf_merge"): + ) as mock_run: pdftool.main() assert mock_run.called - def test_main_merge_custom_output(self) -> None: - """main() should handle merge command with custom output.""" - with patch("sys.argv", ["pdftool", "m", "input.pdf", "--output", "custom.pdf"]), patch.object( - px, "run" - ) as mock_run, patch.object(pdftool, "pdf_merge"): - pdftool.main() - assert mock_run.called - - def test_main_split_file(self) -> None: + def test_main_split_command(self, tmp_path: Path) -> None: """main() should handle split command.""" - with patch("sys.argv", ["pdftool", "s", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_split" - ): + input_file = tmp_path / "input.pdf" + input_file.write_bytes(b"PDF content") + + with patch("sys.argv", ["pdftool", "s", str(input_file)]), patch.object(px, "run") as mock_run: pdftool.main() assert mock_run.called - def test_main_split_custom_output_dir(self) -> None: - """main() should handle split command with custom output dir.""" - with patch("sys.argv", ["pdftool", "s", "input.pdf", "--output-dir", "split"]), patch.object( - px, "run" - ) as mock_run, patch.object(pdftool, "pdf_split"): - pdftool.main() - assert mock_run.called - - def test_main_compress_file(self) -> None: + def test_main_compress_command(self, tmp_path: Path) -> None: """main() should handle compress command.""" - with patch("sys.argv", ["pdftool", "c", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_compress" - ): - pdftool.main() - assert mock_run.called + input_file = tmp_path / "input.pdf" + input_file.write_bytes(b"PDF content") - def test_main_encrypt_file(self) -> None: - """main() should handle encrypt command.""" - with patch("sys.argv", ["pdftool", "e", "input.pdf", "--password", "pass"]), patch.object( - px, "run" - ) as mock_run, patch.object(pdftool, "pdf_encrypt"): - pdftool.main() - assert mock_run.called - - def test_main_decrypt_file(self) -> None: - """main() should handle decrypt command.""" - with patch("sys.argv", ["pdftool", "d", "input.pdf", "--password", "pass"]), patch.object( - px, "run" - ) as mock_run, patch.object(pdftool, "pdf_decrypt"): - pdftool.main() - assert mock_run.called - - def test_main_extract_text_file(self) -> None: - """main() should handle extract text command.""" - with patch("sys.argv", ["pdftool", "xt", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_extract_text" - ): - pdftool.main() - assert mock_run.called - - def test_main_extract_images_file(self) -> None: - """main() should handle extract images command.""" - with patch("sys.argv", ["pdftool", "xi", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_extract_images" - ): - pdftool.main() - assert mock_run.called - - def test_main_watermark_file(self) -> None: - """main() should handle watermark command.""" - with patch("sys.argv", ["pdftool", "w", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_add_watermark" - ): - pdftool.main() - assert mock_run.called - - def test_main_rotate_file(self) -> None: - """main() should handle rotate command.""" - with patch("sys.argv", ["pdftool", "r", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_rotate" - ): - pdftool.main() - assert mock_run.called - - def test_main_crop_file(self) -> None: - """main() should handle crop command.""" - with patch("sys.argv", ["pdftool", "crop", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_crop" - ): - pdftool.main() - assert mock_run.called - - def test_main_info_file(self) -> None: - """main() should handle info command.""" - with patch("sys.argv", ["pdftool", "i", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_info" - ): - pdftool.main() - assert mock_run.called - - def test_main_ocr_file(self) -> None: - """main() should handle ocr command.""" - with patch("sys.argv", ["pdftool", "ocr", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_ocr" - ): - pdftool.main() - assert mock_run.called - - def test_main_to_images_file(self) -> None: - """main() should handle to images command.""" - with patch("sys.argv", ["pdftool", "img", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_to_images" - ): - pdftool.main() - assert mock_run.called - - def test_main_repair_file(self) -> None: - """main() should handle repair command.""" - with patch("sys.argv", ["pdftool", "repair", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_repair" - ): + with patch("sys.argv", ["pdftool", "c", str(input_file)]), patch.object(px, "run") as mock_run: pdftool.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", ["pdftool"]), pytest.raises(SystemExit) as exc_info: + """main() with no args should show help.""" + with patch("sys.argv", ["pdftool"]): pdftool.main() - assert exc_info.value.code == 2 - - def test_main_creates_task_spec_with_correct_name(self) -> None: - """main() should create TaskSpec with correct name.""" - with patch("sys.argv", ["pdftool", "m", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_merge" - ): - pdftool.main() - graph = mock_run.call_args[0][0] - task_names = list(graph.all_specs().keys()) - assert "pdf_merge" in task_names - - def test_main_uses_thread_strategy(self) -> None: - """main() should use thread strategy.""" - with patch("sys.argv", ["pdftool", "m", "input.pdf"]), patch.object(px, "run") as mock_run, patch.object( - pdftool, "pdf_merge" - ): - pdftool.main() - assert mock_run.call_args[1]["strategy"] == "thread" + # Should print help and return diff --git a/tests/cli/test_piptool.py b/tests/cli/test_piptool.py index e1242a6..9a43935 100644 --- a/tests/cli/test_piptool.py +++ b/tests/cli/test_piptool.py @@ -5,8 +5,6 @@ from __future__ import annotations from pathlib import Path from unittest.mock import MagicMock, patch -import pytest - import pyflowx as px from pyflowx.cli import piptool @@ -22,7 +20,6 @@ class TestPipUninstall: with patch("subprocess.run") as mock_run: mock_run.return_value = MagicMock(returncode=0) piptool.pip_uninstall(["numpy"]) - # Should call pip uninstall assert mock_run.called def test_pip_uninstall_multiple_packages(self) -> None: @@ -35,7 +32,9 @@ class TestPipUninstall: def test_pip_uninstall_with_wildcard(self) -> None: """Should handle wildcard in package name.""" - with patch("subprocess.run") as mock_run: + with patch.object(piptool, "_expand_wildcard_packages", return_value=["numpy", "numpy-core"]), patch( + "subprocess.run" + ) as mock_run: mock_run.return_value = MagicMock(returncode=0) piptool.pip_uninstall(["numpy*"]) assert mock_run.called @@ -47,12 +46,13 @@ class TestPipUninstall: class TestPipReinstall: """Test pip_reinstall function.""" - def test_pip_reinstall_online(self) -> None: - """Should reinstall packages online.""" + def test_pip_reinstall_single_package(self) -> None: + """Should reinstall single package.""" with patch("subprocess.run") as mock_run: mock_run.return_value = MagicMock(returncode=0) - piptool.pip_reinstall(["numpy"], offline=False) - assert mock_run.called + piptool.pip_reinstall(["numpy"]) + # Should call pip uninstall and pip install + assert mock_run.call_count == 2 def test_pip_reinstall_offline(self) -> None: """Should reinstall packages offline.""" @@ -69,11 +69,11 @@ class TestPipReinstall: class TestPipDownload: """Test pip_download function.""" - def test_pip_download_online(self) -> None: - """Should download packages online.""" + def test_pip_download_single_package(self) -> None: + """Should download single package.""" with patch("subprocess.run") as mock_run: mock_run.return_value = MagicMock(returncode=0) - piptool.pip_download(["numpy"], offline=False) + piptool.pip_download(["numpy"]) assert mock_run.called def test_pip_download_offline(self) -> None: @@ -91,24 +91,12 @@ class TestPipDownload: class TestPipFreeze: """Test pip_freeze function.""" - def test_pip_freeze_creates_file(self, tmp_path: Path) -> None: - """Should create requirements.txt file.""" - with patch("subprocess.run") as mock_run, patch.object(Path, "cwd", return_value=tmp_path): - mock_run.return_value = MagicMock(stdout="numpy==1.0.0\npandas==2.0.0\n", returncode=0) - piptool.pip_freeze() - # Should create requirements.txt - tmp_path / "requirements.txt" - # Note: The actual implementation might write to current directory - - def test_pip_freeze_calls_subprocess(self) -> None: - """Should call pip freeze.""" + def test_pip_freeze(self, tmp_path: Path) -> None: + """Should freeze dependencies.""" with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(stdout="", returncode=0) + mock_run.return_value = MagicMock(stdout="numpy==1.0.0\npandas==2.0.0", returncode=0) piptool.pip_freeze() assert mock_run.called - call_args = mock_run.call_args[0][0] - assert "pip" in call_args - assert "freeze" in call_args # ---------------------------------------------------------------------- # @@ -117,103 +105,44 @@ class TestPipFreeze: class TestMain: """Test main function.""" - def test_main_install_single_package(self) -> None: - """main() should handle install single package.""" - with patch("sys.argv", ["piptool", "i", "numpy"]), patch.object(px, "run") as mock_run: - piptool.main() - assert mock_run.called - graph = mock_run.call_args[0][0] - specs = graph.all_specs() - for spec in specs.values(): - assert "pip" in spec.cmd - assert "install" in spec.cmd - assert "numpy" in spec.cmd - - def test_main_install_multiple_packages(self) -> None: - """main() should handle install multiple packages.""" - with patch("sys.argv", ["piptool", "i", "numpy", "pandas", "scipy"]), patch.object(px, "run") as mock_run: + def test_main_install_command(self) -> None: + """main() should handle install command.""" + with patch("sys.argv", ["piptool", "i", "numpy", "pandas"]), patch.object(px, "run") as mock_run: piptool.main() assert mock_run.called - def test_main_uninstall_packages(self) -> None: - """main() should handle uninstall packages.""" - with patch("sys.argv", ["piptool", "u", "numpy"]), patch.object(px, "run") as mock_run, patch.object( - piptool, "pip_uninstall" - ): + def test_main_uninstall_command(self) -> None: + """main() should handle uninstall command.""" + with patch("sys.argv", ["piptool", "u", "numpy"]), patch.object(px, "run") as mock_run: piptool.main() assert mock_run.called - def test_main_reinstall_packages(self) -> None: - """main() should handle reinstall packages.""" - with patch("sys.argv", ["piptool", "r", "numpy"]), patch.object(px, "run") as mock_run, patch.object( - piptool, "pip_reinstall" - ): + def test_main_reinstall_command(self) -> None: + """main() should handle reinstall command.""" + with patch("sys.argv", ["piptool", "r", "numpy"]), patch.object(px, "run") as mock_run: piptool.main() assert mock_run.called - def test_main_reinstall_offline(self) -> None: - """main() should handle reinstall offline.""" - with patch("sys.argv", ["piptool", "r", "numpy", "--offline"]), patch.object( - px, "run" - ) as mock_run, patch.object(piptool, "pip_reinstall"): + def test_main_download_command(self) -> None: + """main() should handle download command.""" + with patch("sys.argv", ["piptool", "d", "numpy"]), patch.object(px, "run") as mock_run: piptool.main() assert mock_run.called - def test_main_download_packages(self) -> None: - """main() should handle download packages.""" - with patch("sys.argv", ["piptool", "d", "numpy"]), patch.object(px, "run") as mock_run, patch.object( - piptool, "pip_download" - ): - piptool.main() - assert mock_run.called - - def test_main_download_offline(self) -> None: - """main() should handle download offline.""" - with patch("sys.argv", ["piptool", "d", "numpy", "--offline"]), patch.object( - px, "run" - ) as mock_run, patch.object(piptool, "pip_download"): - piptool.main() - assert mock_run.called - - def test_main_upgrade_pip(self) -> None: - """main() should handle upgrade pip.""" + def test_main_upgrade_command(self) -> None: + """main() should handle upgrade command.""" with patch("sys.argv", ["piptool", "up"]), patch.object(px, "run") as mock_run: piptool.main() assert mock_run.called - graph = mock_run.call_args[0][0] - specs = graph.all_specs() - for spec in specs.values(): - assert "python" in spec.cmd - assert "-m" in spec.cmd - assert "pip" in spec.cmd - assert "install" in spec.cmd - assert "--upgrade" in spec.cmd - def test_main_freeze(self) -> None: - """main() should handle freeze.""" - with patch("sys.argv", ["piptool", "f"]), patch.object(px, "run") as mock_run, patch.object( - piptool, "pip_freeze" - ): + def test_main_freeze_command(self) -> None: + """main() should handle freeze command.""" + with patch("sys.argv", ["piptool", "f"]), patch.object(px, "run") as mock_run: piptool.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", ["piptool"]), pytest.raises(SystemExit) as exc_info: + """main() with no args should show help.""" + with patch("sys.argv", ["piptool"]): piptool.main() - assert exc_info.value.code == 2 - - def test_main_creates_task_specs_with_verbose(self) -> None: - """main() should create TaskSpecs with verbose=True.""" - with patch("sys.argv", ["piptool", "i", "numpy"]), patch.object(px, "run") as mock_run: - piptool.main() - graph = mock_run.call_args[0][0] - specs = graph.all_specs() - for spec in specs.values(): - assert spec.verbose is True - - def test_main_uses_thread_strategy(self) -> None: - """main() should use thread strategy.""" - with patch("sys.argv", ["piptool", "i", "numpy"]), patch.object(px, "run") as mock_run: - piptool.main() - assert mock_run.call_args[1]["strategy"] == "thread" + # Should print help and return diff --git a/tests/cli/test_screenshot.py b/tests/cli/test_screenshot.py index 126741b..4287c1f 100644 --- a/tests/cli/test_screenshot.py +++ b/tests/cli/test_screenshot.py @@ -5,44 +5,60 @@ from __future__ import annotations from pathlib import Path from unittest.mock import MagicMock, patch -import pytest - import pyflowx as px from pyflowx.cli import screenshot from pyflowx.conditions import Constants +# ---------------------------------------------------------------------- # +# get_screenshot_path +# ---------------------------------------------------------------------- # +class TestGetScreenshotPath: + """Test get_screenshot_path function.""" + + def test_get_screenshot_path_with_filename(self, tmp_path: Path) -> None: + """Should get screenshot path with filename.""" + with patch.object(Path, "home", return_value=tmp_path): + result = screenshot.get_screenshot_path("test.png") + assert result.name == "test.png" + + def test_get_screenshot_path_without_filename(self, tmp_path: Path) -> None: + """Should get screenshot path without filename.""" + with patch.object(Path, "home", return_value=tmp_path): + result = screenshot.get_screenshot_path() + assert "screenshot_" in result.name + assert result.suffix == ".png" + + # ---------------------------------------------------------------------- # # take_screenshot_full # ---------------------------------------------------------------------- # class TestTakeScreenshotFull: """Test take_screenshot_full function.""" - def test_take_screenshot_full_windows(self, tmp_path: Path) -> None: # noqa: ARG002 + def test_take_screenshot_full_windows(self, tmp_path: Path) -> None: """Should take full screenshot on Windows.""" - if Constants.IS_WINDOWS: - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - screenshot.take_screenshot_full(filename="test.png") - assert mock_run.called + with patch.object(Constants, "IS_WINDOWS", True), patch.object(Constants, "IS_MACOS", False), patch.object( + Path, "home", return_value=tmp_path + ), patch("subprocess.run") as mock_run: + mock_run.return_value = MagicMock(returncode=0) + screenshot.take_screenshot_full() + assert mock_run.called - def test_take_screenshot_full_linux(self, tmp_path: Path) -> None: # noqa: ARG002 + def test_take_screenshot_full_macos(self, tmp_path: Path) -> None: + """Should take full screenshot on macOS.""" + with patch.object(Constants, "IS_WINDOWS", False), patch.object(Constants, "IS_MACOS", True), patch.object( + Path, "home", return_value=tmp_path + ), patch("subprocess.run") as mock_run: + mock_run.return_value = MagicMock(returncode=0) + screenshot.take_screenshot_full() + assert mock_run.called + + def test_take_screenshot_full_linux(self, tmp_path: Path) -> None: """Should take full screenshot on Linux.""" - with patch.object(Constants, "IS_WINDOWS", False), patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - screenshot.take_screenshot_full(filename="test.png") - assert mock_run.called - - def test_take_screenshot_full_with_custom_filename(self) -> None: - """Should take screenshot with custom filename.""" - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - screenshot.take_screenshot_full(filename="custom.png") - assert mock_run.called - - def test_take_screenshot_full_default_filename(self) -> None: - """Should use default filename.""" - with patch("subprocess.run") as mock_run: + with patch.object(Constants, "IS_WINDOWS", False), patch.object(Constants, "IS_MACOS", False), patch.object( + Path, "home", return_value=tmp_path + ), patch("subprocess.run") as mock_run: mock_run.return_value = MagicMock(returncode=0) screenshot.take_screenshot_full() assert mock_run.called @@ -54,31 +70,29 @@ class TestTakeScreenshotFull: class TestTakeScreenshotArea: """Test take_screenshot_area function.""" - def test_take_screenshot_area_windows(self, tmp_path: Path) -> None: # noqa: ARG002 + def test_take_screenshot_area_windows(self, tmp_path: Path) -> None: """Should take area screenshot on Windows.""" - if Constants.IS_WINDOWS: - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - screenshot.take_screenshot_area(filename="test.png") - assert mock_run.called + with patch.object(Constants, "IS_WINDOWS", True), patch.object(Constants, "IS_MACOS", False), patch.object( + Path, "home", return_value=tmp_path + ), patch("subprocess.run") as mock_run: + mock_run.return_value = MagicMock(returncode=0) + screenshot.take_screenshot_area() + assert mock_run.called - def test_take_screenshot_area_linux(self, tmp_path: Path) -> None: # noqa: ARG002 + def test_take_screenshot_area_macos(self, tmp_path: Path) -> None: + """Should take area screenshot on macOS.""" + with patch.object(Constants, "IS_WINDOWS", False), patch.object(Constants, "IS_MACOS", True), patch.object( + Path, "home", return_value=tmp_path + ), patch("subprocess.run") as mock_run: + mock_run.return_value = MagicMock(returncode=0) + screenshot.take_screenshot_area() + assert mock_run.called + + def test_take_screenshot_area_linux(self, tmp_path: Path) -> None: """Should take area screenshot on Linux.""" - with patch.object(Constants, "IS_WINDOWS", False), patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - screenshot.take_screenshot_area(filename="test.png") - assert mock_run.called - - def test_take_screenshot_area_with_custom_filename(self) -> None: - """Should take screenshot with custom filename.""" - with patch("subprocess.run") as mock_run: - mock_run.return_value = MagicMock(returncode=0) - screenshot.take_screenshot_area(filename="custom.png") - assert mock_run.called - - def test_take_screenshot_area_default_filename(self) -> None: - """Should use default filename.""" - with patch("subprocess.run") as mock_run: + with patch.object(Constants, "IS_WINDOWS", False), patch.object(Constants, "IS_MACOS", False), patch.object( + Path, "home", return_value=tmp_path + ), patch("subprocess.run") as mock_run: mock_run.return_value = MagicMock(returncode=0) screenshot.take_screenshot_area() assert mock_run.called @@ -90,58 +104,20 @@ class TestTakeScreenshotArea: class TestMain: """Test main function.""" - def test_main_full_default_filename(self) -> None: - """main() should handle full command with default filename.""" - with patch("sys.argv", ["screenshot", "full"]), patch.object(px, "run") as mock_run, patch.object( - screenshot, "take_screenshot_full" - ): + def test_main_full_command(self, tmp_path: Path) -> None: + """main() should handle full command.""" + with patch("sys.argv", ["screenshot", "full"]), patch.object(px, "run") as mock_run: screenshot.main() assert mock_run.called - def test_main_full_custom_filename(self) -> None: - """main() should handle full command with custom filename.""" - with patch("sys.argv", ["screenshot", "full", "--filename", "custom.png"]), patch.object( - px, "run" - ) as mock_run, patch.object(screenshot, "take_screenshot_full"): - screenshot.main() - assert mock_run.called - - def test_main_area_default_filename(self) -> None: - """main() should handle area command with default filename.""" - with patch("sys.argv", ["screenshot", "area"]), patch.object(px, "run") as mock_run, patch.object( - screenshot, "take_screenshot_area" - ): - screenshot.main() - assert mock_run.called - - def test_main_area_custom_filename(self) -> None: - """main() should handle area command with custom filename.""" - with patch("sys.argv", ["screenshot", "area", "--filename", "custom.png"]), patch.object( - px, "run" - ) as mock_run, patch.object(screenshot, "take_screenshot_area"): + def test_main_area_command(self, tmp_path: Path) -> None: + """main() should handle area command.""" + with patch("sys.argv", ["screenshot", "area"]), patch.object(px, "run") as mock_run: screenshot.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", ["screenshot"]), pytest.raises(SystemExit) as exc_info: + """main() with no args should show help.""" + with patch("sys.argv", ["screenshot"]): screenshot.main() - assert exc_info.value.code == 2 - - def test_main_creates_task_spec_with_correct_name(self) -> None: - """main() should create TaskSpec with correct name.""" - with patch("sys.argv", ["screenshot", "full"]), patch.object(px, "run") as mock_run, patch.object( - screenshot, "take_screenshot_full" - ): - screenshot.main() - graph = mock_run.call_args[0][0] - task_names = list(graph.all_specs().keys()) - assert "screenshot_full" in task_names - - def test_main_uses_thread_strategy(self) -> None: - """main() should use thread strategy.""" - with patch("sys.argv", ["screenshot", "full"]), patch.object(px, "run") as mock_run, patch.object( - screenshot, "take_screenshot_full" - ): - screenshot.main() - assert mock_run.call_args[1]["strategy"] == "thread" + # Should print help and return diff --git a/tests/test_context.py b/tests/test_context.py index 901c746..93cd315 100644 --- a/tests/test_context.py +++ b/tests/test_context.py @@ -136,7 +136,7 @@ class TestDescribeInjection: def test_describe_injection(self) -> None: """应正确描述依赖注入、Context 标注和默认值.""" - def fn(a: int, ctx: px.Context, flag: bool = False) -> None: # noqa: ARG001 + def fn(a: int, ctx: px.Context, flag: bool = False) -> None: return None spec = px.TaskSpec("t", fn, depends_on=("a",)) @@ -148,7 +148,7 @@ class TestDescribeInjection: def test_var_positional(self) -> None: """*args 参数应显示为 *args.""" - def fn(*args: Any) -> None: # noqa: ARG001 + def fn(*args: Any) -> None: return None spec = px.TaskSpec("t", fn) @@ -158,7 +158,7 @@ class TestDescribeInjection: def test_var_keyword(self) -> None: """**kwargs 参数应显示为 **kwargs=.""" - def fn(**kwargs: Any) -> None: # pyright: ignore[reportExplicitAny, reportAny] # noqa: ARG001 + def fn(**kwargs: Any) -> None: # pyright: ignore[reportExplicitAny, reportAny] return None spec = px.TaskSpec("t", fn, depends_on=("a",)) @@ -168,7 +168,7 @@ class TestDescribeInjection: def test_unresolved(self) -> None: """无依赖、无静态值、无默认的参数应显示为 .""" - def fn(missing: int) -> None: # noqa: ARG001 + def fn(missing: int) -> None: return None spec = px.TaskSpec("t", fn) @@ -178,7 +178,7 @@ class TestDescribeInjection: def test_static_kwargs(self) -> None: """静态 kwargs 应显示具体值.""" - def fn(flag: bool = False) -> None: # noqa: ARG001 + def fn(flag: bool = False) -> None: return None spec = px.TaskSpec("t", fn, kwargs={"flag": True}) @@ -188,7 +188,7 @@ class TestDescribeInjection: def test_positional_args_filled(self) -> None: """spec.args 填充的位置参数应显示具体值（覆盖 args_filled 分支）.""" - def fn(a: int, b: str) -> None: # noqa: ARG001 + def fn(a: int, b: str) -> None: return None spec = px.TaskSpec("t", fn, args=(1, "x"))