Coverage for tests / unit / pytest / test_pytest_cli_options.py: 100%

1"""Tests for pytest CLI test command.""" 

2 

3import tempfile 

4from pathlib import Path 

5from unittest.mock import patch 

6 

7from assertpy import assert_that 

8from click.testing import CliRunner 

9 

10from lintro.cli_utils.commands.test import test_command 

11 

12 

13def test_test_command_help() -> None: 

14 """Test that test command shows help.""" 

15 runner = CliRunner() 

16 result = runner.invoke(test_command, ["--help"]) 

17 assert_that(result.exit_code).is_equal_to(0) 

18 assert_that(result.output).contains("Run tests using pytest") 

19 

20 

21def test_test_command_default_paths() -> None: 

22 """Test test command with default paths.""" 

23 runner = CliRunner() 

24 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

25 mock_run.return_value = 0 

26 runner.invoke(test_command, []) 

27 assert_that(mock_run.called).is_true() 

28 call_args = mock_run.call_args 

29 assert_that(call_args.kwargs["paths"]).is_equal_to(["."]) 

30 assert_that(call_args.kwargs["tools"]).is_equal_to("pytest") 

31 

32 

33def test_test_command_explicit_paths() -> None: 

34 """Test test command with explicit paths.""" 

35 runner = CliRunner() 

36 with tempfile.TemporaryDirectory() as tmpdir: 

37 test_dir = Path(tmpdir) 

38 (test_dir / "test_file.py").write_text("def test(): pass\n") 

39 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

40 mock_run.return_value = 0 

41 runner.invoke( 

42 test_command, 

43 [str(test_dir / "test_file.py")], 

44 ) 

45 call_args = mock_run.call_args 

46 assert_that(call_args.kwargs["paths"]).contains( 

47 str(test_dir / "test_file.py"), 

48 ) 

49 

50 

51def test_test_command_exclude_patterns() -> None: 

52 """Test test command with exclude patterns.""" 

53 runner = CliRunner() 

54 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

55 mock_run.return_value = 0 

56 runner.invoke( 

57 test_command, 

58 ["--exclude", "*.venv,__pycache__"], 

59 ) 

60 call_args = mock_run.call_args 

61 assert_that(call_args.kwargs["exclude"]).is_equal_to("*.venv,__pycache__") 

62 

63 

64def test_test_command_include_venv() -> None: 

65 """Test test command with include-venv flag.""" 

66 runner = CliRunner() 

67 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

68 mock_run.return_value = 0 

69 runner.invoke(test_command, ["--include-venv"]) 

70 call_args = mock_run.call_args 

71 assert_that(call_args.kwargs["include_venv"]).is_true() 

72 

73 

74def test_test_command_output_format() -> None: 

75 """Test test command with output format option.""" 

76 runner = CliRunner() 

77 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

78 mock_run.return_value = 0 

79 runner.invoke( 

80 test_command, 

81 ["--output-format", "json"], 

82 ) 

83 call_args = mock_run.call_args 

84 assert_that(call_args.kwargs["output_format"]).is_equal_to("json") 

85 

86 

87def test_test_command_group_by() -> None: 

88 """Test test command with group-by option.""" 

89 runner = CliRunner() 

90 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

91 mock_run.return_value = 0 

92 runner.invoke(test_command, ["--group-by", "code"]) 

93 call_args = mock_run.call_args 

94 assert_that(call_args.kwargs["group_by"]).is_equal_to("code") 

95 

96 

97def test_test_command_verbose() -> None: 

98 """Test test command with verbose flag.""" 

99 runner = CliRunner() 

100 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

101 mock_run.return_value = 0 

102 runner.invoke(test_command, ["--verbose"]) 

103 call_args = mock_run.call_args 

104 assert_that(call_args.kwargs["verbose"]).is_true() 

105 

106 

107def test_test_command_raw_output() -> None: 

108 """Test test command with raw-output flag.""" 

109 runner = CliRunner() 

110 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

111 mock_run.return_value = 0 

112 runner.invoke(test_command, ["--raw-output"]) 

113 call_args = mock_run.call_args 

114 assert_that(call_args.kwargs["raw_output"]).is_true() 

115 

116 

117def test_test_command_list_plugins() -> None: 

118 """Test test command with --list-plugins flag.""" 

119 runner = CliRunner() 

120 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

121 mock_run.return_value = 0 

122 runner.invoke(test_command, ["--list-plugins"]) 

123 call_args = mock_run.call_args 

124 assert_that(call_args.kwargs["tool_options"]).contains( 

125 "pytest:list_plugins=True", 

126 ) 

127 

128 

129def test_test_command_check_plugins() -> None: 

130 """Test test command with --check-plugins flag.""" 

131 runner = CliRunner() 

132 with patch("lintro.cli_utils.commands.test.run_lint_tools_simple") as mock_run: 

133 mock_run.return_value = 0 

134 runner.invoke( 

135 test_command, 

136 [ 

137 "--check-plugins", 

138 "--tool-options", 

139 "pytest:required_plugins=pytest-cov,pytest-xdist", 

140 ], 

141 ) 

142 call_args = mock_run.call_args 

143 assert_that(call_args.kwargs["tool_options"]).contains( 

144 "pytest:check_plugins=True", 

145 ) 

146 assert_that(call_args.kwargs["tool_options"]).contains( 

147 "pytest:required_plugins=pytest-cov,pytest-xdist", 

148 )