1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
from typing import Callable, List
from unittest import mock
import pytest
from pip._internal.cli.base_command import Command
from pip._internal.cli.req_command import (
IndexGroupCommand,
RequirementCommand,
SessionCommandMixin,
)
from pip._internal.commands import commands_dict, create_command
# These are the expected names of the commands whose classes inherit from
# IndexGroupCommand.
EXPECTED_INDEX_GROUP_COMMANDS = ["download", "index", "install", "list", "wheel"]
def check_commands(pred: Callable[[Command], bool], expected: List[str]) -> None:
"""
Check the commands satisfying a predicate.
"""
commands = [create_command(name) for name in sorted(commands_dict)]
actual = [command.name for command in commands if pred(command)]
assert actual == expected, f"actual: {actual}"
def test_commands_dict__order() -> None:
"""
Check the ordering of commands_dict.
"""
names = list(commands_dict)
# A spot-check is sufficient to check that commands_dict encodes an
# ordering.
assert names[0] == "install"
assert names[-1] == "help"
@pytest.mark.parametrize("name", list(commands_dict))
def test_create_command(name: str) -> None:
"""Test creating an instance of each available command."""
command = create_command(name)
assert command.name == name
assert command.summary == commands_dict[name].summary
def test_session_commands() -> None:
"""
Test which commands inherit from SessionCommandMixin.
"""
def is_session_command(command: Command) -> bool:
return isinstance(command, SessionCommandMixin)
expected = ["download", "index", "install", "list", "search", "uninstall", "wheel"]
check_commands(is_session_command, expected)
def test_index_group_commands() -> None:
"""
Test the commands inheriting from IndexGroupCommand.
"""
def is_index_group_command(command: Command) -> bool:
return isinstance(command, IndexGroupCommand)
check_commands(is_index_group_command, EXPECTED_INDEX_GROUP_COMMANDS)
# Also check that the commands inheriting from IndexGroupCommand are
# exactly the commands with the --no-index option.
def has_option_no_index(command: Command) -> bool:
return command.parser.has_option("--no-index")
check_commands(has_option_no_index, EXPECTED_INDEX_GROUP_COMMANDS)
@pytest.mark.parametrize("command_name", EXPECTED_INDEX_GROUP_COMMANDS)
@pytest.mark.parametrize(
"disable_pip_version_check, no_index, expected_called",
[
# pip_self_version_check() is only called when both
# disable_pip_version_check and no_index are False.
(False, False, True),
(False, True, False),
(True, False, False),
(True, True, False),
],
)
@mock.patch("pip._internal.cli.req_command.pip_self_version_check")
def test_index_group_handle_pip_version_check(
mock_version_check: mock.Mock,
command_name: str,
disable_pip_version_check: bool,
no_index: bool,
expected_called: bool,
) -> None:
"""
Test whether pip_self_version_check() is called when
handle_pip_version_check() is called, for each of the
IndexGroupCommand classes.
"""
command = create_command(command_name)
options = command.parser.get_default_values()
options.disable_pip_version_check = disable_pip_version_check
options.no_index = no_index
command.handle_pip_version_check(options)
if expected_called:
mock_version_check.assert_called_once()
else:
mock_version_check.assert_not_called()
def test_requirement_commands() -> None:
"""
Test which commands inherit from RequirementCommand.
"""
def is_requirement_command(command: Command) -> bool:
return isinstance(command, RequirementCommand)
check_commands(is_requirement_command, ["download", "install", "wheel"])
|
