Coverage for tests / test_launch.py: 100%

1import io 7 ctx1acfgbde

2import subprocess 7 ctx1acfgbde

3from unittest.mock import Mock, patch 7 ctx1acfgbde

4 

5import pytest 7 ctx1acfgbde

6import typer 7 ctx1acfgbde

7 

8from tests.utils import needs_linux, needs_macos, needs_windows 7 ctx1acfgbde

9 

10url = "http://example.com" 7 ctx1acfgbde

11 

12 

13@pytest.mark.parametrize( 7 ctx1acfgbde

14 "system, command", 

15 [ 

16 ("Darwin", "open"), 

17 ("Linux", "xdg-open"), 

18 ("FreeBSD", "xdg-open"), 

19 ], 

20) 

21def test_launch_url_unix(system: str, command: str): 7 ctx1acfgbde

22 with ( 2 ctx1ab

23 patch("platform.system", return_value=system), 

24 patch("shutil.which", return_value=True), 

25 patch("subprocess.Popen") as mock_popen, 

26 ): 

27 typer.launch(url) 7 ctx1acfgbde

28 

29 mock_popen.assert_called_once_with( 7 ctx1acfgbde

30 [command, url], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT 

31 ) 

32 

33 

34def test_launch_url_windows(): 7 ctx1acfgbde

35 with ( 2 ctx1ab

36 patch("platform.system", return_value="Windows"), 

37 patch("webbrowser.open") as mock_webbrowser_open, 

38 ): 

39 typer.launch(url) 7 ctx1acfgbde

40 

41 mock_webbrowser_open.assert_called_once_with(url) 7 ctx1acfgbde

42 

43 

44def test_launch_url_no_xdg_open(): 7 ctx1acfgbde

45 with ( 2 ctx1ab

46 patch("platform.system", return_value="Linux"), 

47 patch("shutil.which", return_value=None), 

48 patch("webbrowser.open") as mock_webbrowser_open, 

49 ): 

50 typer.launch(url) 7 ctx1acfgbde

51 

52 mock_webbrowser_open.assert_called_once_with(url) 7 ctx1acfgbde

53 

54 

55def test_launch_url_linux_xdg_open_does_not_wait_by_default(): 7 ctx1acfgbde

56 proc = Mock() 7 ctx1acfgbde

57 

58 with ( 2 ctx1ab

59 patch("platform.system", return_value="Linux"), 

60 patch("shutil.which", return_value=True), 

61 patch("subprocess.Popen", return_value=proc) as mock_popen, 

62 ): 

63 result = typer.launch(url) 7 ctx1acfgbde

64 

65 assert result == 0 7 ctx1acfgbde

66 mock_popen.assert_called_once_with( 7 ctx1acfgbde

67 ["xdg-open", url], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT 

68 ) 

69 proc.wait.assert_not_called() 7 ctx1acfgbde

70 

71 

72def test_launch_url_linux_xdg_open_waits_when_requested(): 7 ctx1acfgbde

73 proc = Mock() 7 ctx1acfgbde

74 proc.wait.return_value = 42 7 ctx1acfgbde

75 

76 with ( 2 ctx1ab

77 patch("platform.system", return_value="Linux"), 

78 patch("shutil.which", return_value=True), 

79 patch("subprocess.Popen", return_value=proc) as mock_popen, 

80 ): 

81 result = typer.launch(url, wait=True) 7 ctx1acfgbde

82 

83 assert result == 42 7 ctx1acfgbde

84 mock_popen.assert_called_once_with( 7 ctx1acfgbde

85 ["xdg-open", url], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT 

86 ) 

87 proc.wait.assert_called_once_with() 7 ctx1acfgbde

88 

89 

90@pytest.fixture 7 ctx1acfgbde

91def allow_dev_null(monkeypatch): 7 ctx1acfgbde

92 real_open = open 3 ctx1bde

93 

94 def fake_open(path, *args, **kwargs): 3 ctx1bde

95 if path == "/dev/null": 3 ctx1bde

96 return io.StringIO() 3 ctx1bde

97 return real_open(path, *args, **kwargs) # pragma: no cover 

98 

99 monkeypatch.setattr("builtins.open", fake_open) 3 ctx1bde

100 

101 

102@needs_macos 7 ctx1acfgbde

103def test_open_url_macos(monkeypatch, allow_dev_null): 7 ctx1acfgbde

104 recorded: list[list[str]] = [] 3 ctx1bde

105 

106 class Proc: 3 ctx1bde

107 def wait(self) -> int: 3 ctx1bde

108 return 42 3 ctx1bde

109 

110 def fake_popen(args, **kwargs): 3 ctx1bde

111 recorded.append(list(args)) 3 ctx1bde

112 return Proc() 3 ctx1bde

113 

114 monkeypatch.setattr(subprocess, "Popen", fake_popen) 3 ctx1bde

115 

116 assert typer.launch("/path/to/file", wait=True, locate=True) == 42 3 ctx1bde

117 assert recorded[0][:3] == ["open", "-W", "-R"] 3 ctx1bde

118 assert recorded[0][-1] == "/path/to/file" 3 ctx1bde

119 

120 

121@needs_windows 7 ctx1acfgbde

122def test_launch_files_windows(monkeypatch): 7 ctx1acfgbde

123 calls: list[list[str]] = [] 2 ctx1fg

124 

125 def fake_call(args): 2 ctx1fg

126 calls.append(list(args)) 2 ctx1fg

127 return 0 2 ctx1fg

128 

129 monkeypatch.setattr(subprocess, "call", fake_call) 2 ctx1fg

130 

131 assert typer.launch("C:/Tools/readme.txt", wait=True, locate=False) == 0 2 ctx1fg

132 assert typer.launch("file:///C:/tmp/a.txt", wait=False, locate=True) == 0 2 ctx1fg

133 assert calls.pop(0) == ["start", "/WAIT", "", "C:/Tools/readme.txt"] 2 ctx1fg

134 assert calls.pop(0) == ["explorer", "/select,/C:/tmp/a.txt"] 2 ctx1fg

135 

136 monkeypatch.setattr(subprocess, "call", lambda a: (_ for _ in ()).throw(OSError())) 2 ctx1fg

137 assert typer.launch("D:/no/such/file.txt", wait=False, locate=False) == 127 2 ctx1fg

138 

139 

140@needs_linux 7 ctx1acfgbde

141def test_open_url_linux_wait(monkeypatch): 7 ctx1acfgbde

142 class Proc: 2 ctx1ac

143 def __init__(self, code: int = 0) -> None: 2 ctx1ac

144 self._code = code 2 ctx1ac

145 

146 def wait(self) -> int: 2 ctx1ac

147 return self._code 2 ctx1ac

148 

149 monkeypatch.setattr(subprocess, "Popen", lambda *a, **k: Proc(7)) 2 ctx1ac

150 

151 assert typer.launch("/file", wait=True, locate=False) == 7 2 ctx1ac

152 

153 

154@needs_linux 7 ctx1acfgbde

155def test_open_url_linux_locate(monkeypatch): 7 ctx1acfgbde

156 recorded: list[list[str]] = [] 2 ctx1ac

157 

158 class Proc: 2 ctx1ac

159 def wait(self) -> int: 2 ctx1ac

160 return 0 # pragma: no cover 

161 

162 def fake_popen(args, **kwargs): 2 ctx1ac

163 recorded.append(list(args)) 2 ctx1ac

164 return Proc() 2 ctx1ac

165 

166 monkeypatch.setattr(subprocess, "Popen", fake_popen) 2 ctx1ac

167 

168 assert typer.launch("/tmp/sub/file.txt", wait=False, locate=True) == 0 2 ctx1ac

169 assert recorded[-1] == ["xdg-open", "/tmp/sub"] 2 ctx1ac

170 

171 

172@needs_windows 7 ctx1acfgbde

173def test_launch_file(): 7 ctx1acfgbde

174 with ( 

175 patch("typer._click._termui_impl.sys.platform", "win32"), 

176 patch("typer._click._termui_impl.WIN", True), 

177 patch("typer._click._termui_impl.CYGWIN", False), 

178 patch("subprocess.call", return_value=0) as call_mock, 

179 ): 

180 result = typer.launch("C:/tmp/file.txt", locate=True) 2 ctx1fg

181 

182 assert result == 0 2 ctx1fg

183 call_mock.assert_called_once_with(["explorer", "/select,C:/tmp/file.txt"]) 2 ctx1fg