Coverage for tests/test_type_conversion.py: 100%

1from enum import Enum 8 ctx1habcdefg

2from pathlib import Path 8 ctx1habcdefg

3from typing import Any, List, Optional, Tuple 8 ctx1habcdefg

4 

5import click 8 ctx1habcdefg

6import pytest 8 ctx1habcdefg

7import typer 8 ctx1habcdefg

8from typer.testing import CliRunner 8 ctx1habcdefg

9 

10runner = CliRunner() 8 ctx1habcdefg

11 

12 

13def test_optional(): 8 ctx1habcdefg

14 app = typer.Typer() 8 ctx1habcdefg

15 

16 @app.command() 8 ctx1habcdefg

17 def opt(user: Optional[str] = None): 8 ctx1habcdefg

18 if user: 8 ctx1habcdefg

19 print(f"User: {user}") 8 ctx1habcdefg

20 else: 

21 print("No user") 8 ctx1habcdefg

22 

23 result = runner.invoke(app) 8 ctx1habcdefg

24 assert result.exit_code == 0 8 ctx1habcdefg

25 assert "No user" in result.output 8 ctx1habcdefg

26 

27 result = runner.invoke(app, ["--user", "Camila"]) 8 ctx1habcdefg

28 assert result.exit_code == 0 8 ctx1habcdefg

29 assert "User: Camila" in result.output 8 ctx1habcdefg

30 

31 

32def test_optional_tuple(): 8 ctx1habcdefg

33 app = typer.Typer() 8 ctx1habcdefg

34 

35 @app.command() 8 ctx1habcdefg

36 def opt(number: Optional[Tuple[int, int]] = None): 8 ctx1habcdefg

37 if number: 8 ctx1habcdefg

38 print(f"Number: {number}") 8 ctx1habcdefg

39 else: 

40 print("No number") 8 ctx1habcdefg

41 

42 result = runner.invoke(app) 8 ctx1habcdefg

43 assert result.exit_code == 0 8 ctx1habcdefg

44 assert "No number" in result.output 8 ctx1habcdefg

45 

46 result = runner.invoke(app, ["--number", "4", "2"]) 8 ctx1habcdefg

47 assert result.exit_code == 0 8 ctx1habcdefg

48 assert "Number: (4, 2)" in result.output 8 ctx1habcdefg

49 

50 

51def test_no_type(): 8 ctx1habcdefg

52 app = typer.Typer() 8 ctx1habcdefg

53 

54 @app.command() 8 ctx1habcdefg

55 def no_type(user): 7 ctx1abcdefg

56 print(f"User: {user}") 8 ctx1habcdefg

57 

58 result = runner.invoke(app, ["Camila"]) 8 ctx1habcdefg

59 assert result.exit_code == 0 8 ctx1habcdefg

60 assert "User: Camila" in result.output 8 ctx1habcdefg

61 

62 

63class SomeEnum(Enum): 8 ctx1habcdefg

64 ONE = "one" 8 ctx1habcdefg

65 TWO = "two" 8 ctx1habcdefg

66 THREE = "three" 8 ctx1habcdefg

67 

68 

69@pytest.mark.parametrize( 8 ctx1habcdefg

70 "type_annotation", 

71 [List[Path], List[SomeEnum], List[str]], 

72) 

73def test_list_parameters_convert_to_lists(type_annotation): 7 ctx1abcdefg

74 # Lists containing objects that are converted by Click (i.e. not Path or Enum) 

75 # should not be inadvertently converted to tuples 

76 expected_element_type = type_annotation.__args__[0] 8 ctx1habcdefg

77 app = typer.Typer() 8 ctx1habcdefg

78 

79 @app.command() 8 ctx1habcdefg

80 def list_conversion(container: type_annotation): 8 ctx1habcdefg

81 assert isinstance(container, list) 8 ctx1habcdefg

82 for element in container: 8 ctx1habcdefg

83 assert isinstance(element, expected_element_type) 8 ctx1habcdefg

84 

85 result = runner.invoke(app, ["one", "two", "three"]) 8 ctx1habcdefg

86 assert result.exit_code == 0 8 ctx1habcdefg

87 

88 

89@pytest.mark.parametrize( 8 ctx1habcdefg

90 "type_annotation", 

91 [ 

92 Tuple[str, str], 

93 Tuple[str, Path], 

94 Tuple[Path, Path], 

95 Tuple[str, SomeEnum], 

96 Tuple[SomeEnum, SomeEnum], 

97 ], 

98) 

99def test_tuple_parameter_elements_are_converted_recursively(type_annotation): 7 ctx1abcdefg

100 # Tuple elements that aren't converted by Click (i.e. Path or Enum) 

101 # should be recursively converted by Typer 

102 expected_element_types = type_annotation.__args__ 8 ctx1habcdefg

103 app = typer.Typer() 8 ctx1habcdefg

104 

105 @app.command() 8 ctx1habcdefg

106 def tuple_recursive_conversion(container: type_annotation): 8 ctx1habcdefg

107 assert isinstance(container, tuple) 8 ctx1habcdefg

108 for element, expected_type in zip(container, expected_element_types): 8 ctx1habcdefg

109 assert isinstance(element, expected_type) 8 ctx1habcdefg

110 

111 result = runner.invoke(app, ["one", "two"]) 8 ctx1habcdefg

112 assert result.exit_code == 0 8 ctx1habcdefg

113 

114 

115def test_custom_parse(): 8 ctx1habcdefg

116 app = typer.Typer() 8 ctx1habcdefg

117 

118 @app.command() 8 ctx1habcdefg

119 def custom_parser( 7 ctx1abcdefg

120 hex_value: int = typer.Argument(None, parser=lambda x: int(x, 0)), 

121 ): 

122 assert hex_value == 0x56 8 ctx1habcdefg

123 

124 result = runner.invoke(app, ["0x56"]) 8 ctx1habcdefg

125 assert result.exit_code == 0 8 ctx1habcdefg

126 

127 

128def test_custom_click_type(): 8 ctx1habcdefg

129 class BaseNumberParamType(click.ParamType): 8 ctx1habcdefg

130 name = "base_integer" 8 ctx1habcdefg

131 

132 def convert( 7 ctx1abcdefg

133 self, 

134 value: Any, 

135 param: Optional[click.Parameter], 

136 ctx: Optional[click.Context], 

137 ) -> Any: 

138 return int(value, 0) 8 ctx1habcdefg

139 

140 app = typer.Typer() 8 ctx1habcdefg

141 

142 @app.command() 8 ctx1habcdefg

143 def custom_click_type( 7 ctx1abcdefg

144 hex_value: int = typer.Argument(None, click_type=BaseNumberParamType()), 

145 ): 

146 assert hex_value == 0x56 8 ctx1habcdefg

147 

148 result = runner.invoke(app, ["0x56"]) 8 ctx1habcdefg

149 assert result.exit_code == 0 8 ctx1habcdefg