Debian Codegraph @

Lib/test/test_code_module.py

raw
1 "Test InteractiveConsole and InteractiveInterpreter from code module"
2 import sys
3 import traceback
4 import unittest
5 from textwrap import dedent
6 from contextlib import ExitStack
7 from unittest import mock
8 from test.support import force_not_colorized_test_class
9 from test.support import import_helper
10
11 code = import_helper.import_module('code')
12
13
14 class MockSys:
15
16 def mock_sys(self):
17 "Mock system environment for InteractiveConsole"
18 # use exit stack to match patch context managers to addCleanup
19 stack = ExitStack()
20 self.addCleanup(stack.close)
21 self.infunc = stack.enter_context(mock.patch('code.input',
22 create=True))
23 self.stdout = stack.enter_context(mock.patch('code.sys.stdout'))
24 self.stderr = stack.enter_context(mock.patch('code.sys.stderr'))
25 prepatch = mock.patch('code.sys', wraps=code.sys, spec=code.sys)
26 self.sysmod = stack.enter_context(prepatch)
27 if sys.excepthook is sys.__excepthook__:
28 self.sysmod.excepthook = self.sysmod.__excepthook__
29 del self.sysmod.ps1
30 del self.sysmod.ps2
31
32
33 @force_not_colorized_test_class
34 class TestInteractiveConsole(unittest.TestCase, MockSys):
35 maxDiff = None
36
37 def setUp(self):
38 self.console = code.InteractiveConsole()
39 self.mock_sys()
40
41 def test_ps1(self):
42 self.infunc.side_effect = [
43 "import code",
44 "code.sys.ps1",
45 EOFError('Finished')
46 ]
47 self.console.interact()
48 output = ''.join(''.join(call[1]) for call in self.stdout.method_calls)
49 self.assertIn('>>> ', output)
50 self.assertNotHasAttr(self.sysmod, 'ps1')
51
52 self.infunc.side_effect = [
53 "import code",
54 "code.sys.ps1",
55 EOFError('Finished')
56 ]
57 self.sysmod.ps1 = 'custom1> '
58 self.console.interact()
59 output = ''.join(''.join(call[1]) for call in self.stdout.method_calls)
60 self.assertIn('custom1> ', output)
61 self.assertEqual(self.sysmod.ps1, 'custom1> ')
62
63 def test_ps2(self):
64 self.infunc.side_effect = [
65 "import code",
66 "code.sys.ps2",
67 EOFError('Finished')
68 ]
69 self.console.interact()
70 output = ''.join(''.join(call[1]) for call in self.stdout.method_calls)
71 self.assertIn('... ', output)
72 self.assertNotHasAttr(self.sysmod, 'ps2')
73
74 self.infunc.side_effect = [
75 "import code",
76 "code.sys.ps2",
77 EOFError('Finished')
78 ]
79 self.sysmod.ps2 = 'custom2> '
80 self.console.interact()
81 output = ''.join(''.join(call[1]) for call in self.stdout.method_calls)
82 self.assertIn('custom2> ', output)
83 self.assertEqual(self.sysmod.ps2, 'custom2> ')
84
85 def test_console_stderr(self):
86 self.infunc.side_effect = ["'antioch'", "", EOFError('Finished')]
87 self.console.interact()
88 for call in list(self.stdout.method_calls):
89 if 'antioch' in ''.join(call[1]):
90 break
91 else:
92 raise AssertionError("no console stdout")
93
94 def test_syntax_error(self):
95 self.infunc.side_effect = ["def f():",
96 " x = ?",
97 "",
98 EOFError('Finished')]
99 self.console.interact()
100 output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
101 output = output[output.index('(InteractiveConsole)'):]
102 output = output[:output.index('\nnow exiting')]
103 self.assertEqual(output.splitlines()[1:], [
104 ' File "<console>", line 2',
105 ' x = ?',
106 ' ^',
107 'SyntaxError: invalid syntax'])
108 self.assertIs(self.sysmod.last_type, SyntaxError)
109 self.assertIs(type(self.sysmod.last_value), SyntaxError)
110 self.assertIsNone(self.sysmod.last_traceback)
111 self.assertIsNone(self.sysmod.last_value.__traceback__)
112 self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
113
114 def test_indentation_error(self):
115 self.infunc.side_effect = [" 1", EOFError('Finished')]
116 self.console.interact()
117 output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
118 output = output[output.index('(InteractiveConsole)'):]
119 output = output[:output.index('\nnow exiting')]
120 self.assertEqual(output.splitlines()[1:], [
121 ' File "<console>", line 1',
122 ' 1',
123 'IndentationError: unexpected indent'])
124 self.assertIs(self.sysmod.last_type, IndentationError)
125 self.assertIs(type(self.sysmod.last_value), IndentationError)
126 self.assertIsNone(self.sysmod.last_traceback)
127 self.assertIsNone(self.sysmod.last_value.__traceback__)
128 self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
129
130 def test_unicode_error(self):
131 self.infunc.side_effect = ["'\ud800'", EOFError('Finished')]
132 self.console.interact()
133 output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
134 output = output[output.index('(InteractiveConsole)'):]
135 output = output[output.index('\n') + 1:]
136 self.assertStartsWith(output, 'UnicodeEncodeError: ')
137 self.assertIs(self.sysmod.last_type, UnicodeEncodeError)
138 self.assertIs(type(self.sysmod.last_value), UnicodeEncodeError)
139 self.assertIsNone(self.sysmod.last_traceback)
140 self.assertIsNone(self.sysmod.last_value.__traceback__)
141 self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
142
143 def test_sysexcepthook(self):
144 self.infunc.side_effect = ["def f():",
145 " raise ValueError('BOOM!')",
146 "",
147 "f()",
148 EOFError('Finished')]
149 hook = mock.Mock()
150 self.sysmod.excepthook = hook
151 self.console.interact()
152 hook.assert_called()
153 hook.assert_called_with(self.sysmod.last_type,
154 self.sysmod.last_value,
155 self.sysmod.last_traceback)
156 self.assertIs(self.sysmod.last_type, ValueError)
157 self.assertIs(type(self.sysmod.last_value), ValueError)
158 self.assertIs(self.sysmod.last_traceback, self.sysmod.last_value.__traceback__)
159 self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
160 self.assertEqual(traceback.format_exception(self.sysmod.last_exc), [
161 'Traceback (most recent call last):\n',
162 ' File "<console>", line 1, in <module>\n',
163 ' File "<console>", line 2, in f\n',
164 'ValueError: BOOM!\n'])
165
166 def test_sysexcepthook_syntax_error(self):
167 self.infunc.side_effect = ["def f():",
168 " x = ?",
169 "",
170 EOFError('Finished')]
171 hook = mock.Mock()
172 self.sysmod.excepthook = hook
173 self.console.interact()
174 hook.assert_called()
175 hook.assert_called_with(self.sysmod.last_type,
176 self.sysmod.last_value,
177 self.sysmod.last_traceback)
178 self.assertIs(self.sysmod.last_type, SyntaxError)
179 self.assertIs(type(self.sysmod.last_value), SyntaxError)
180 self.assertIsNone(self.sysmod.last_traceback)
181 self.assertIsNone(self.sysmod.last_value.__traceback__)
182 self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
183 self.assertEqual(traceback.format_exception(self.sysmod.last_exc), [
184 ' File "<console>", line 2\n',
185 ' x = ?\n',
186 ' ^\n',
187 'SyntaxError: invalid syntax\n'])
188
189 def test_sysexcepthook_indentation_error(self):
190 self.infunc.side_effect = [" 1", EOFError('Finished')]
191 hook = mock.Mock()
192 self.sysmod.excepthook = hook
193 self.console.interact()
194 hook.assert_called()
195 hook.assert_called_with(self.sysmod.last_type,
196 self.sysmod.last_value,
197 self.sysmod.last_traceback)
198 self.assertIs(self.sysmod.last_type, IndentationError)
199 self.assertIs(type(self.sysmod.last_value), IndentationError)
200 self.assertIsNone(self.sysmod.last_traceback)
201 self.assertIsNone(self.sysmod.last_value.__traceback__)
202 self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
203 self.assertEqual(traceback.format_exception(self.sysmod.last_exc), [
204 ' File "<console>", line 1\n',
205 ' 1\n',
206 'IndentationError: unexpected indent\n'])
207
208 def test_sysexcepthook_crashing_doesnt_close_repl(self):
209 self.infunc.side_effect = ["1/0", "a = 123", "print(a)", EOFError('Finished')]
210 self.sysmod.excepthook = 1
211 self.console.interact()
212 self.assertEqual(['write', ('123', ), {}], self.stdout.method_calls[0])
213 error = "".join(call.args[0] for call in self.stderr.method_calls if call[0] == 'write')
214 self.assertIn("Error in sys.excepthook:", error)
215 self.assertEqual(error.count("'int' object is not callable"), 1)
216 self.assertIn("Original exception was:", error)
217 self.assertIn("division by zero", error)
218
219 def test_sysexcepthook_raising_BaseException(self):
220 self.infunc.side_effect = ["1/0", "a = 123", "print(a)", EOFError('Finished')]
221 s = "not so fast"
222 def raise_base(*args, **kwargs):
223 raise BaseException(s)
224 self.sysmod.excepthook = raise_base
225 self.console.interact()
226 self.assertEqual(['write', ('123', ), {}], self.stdout.method_calls[0])
227 error = "".join(call.args[0] for call in self.stderr.method_calls if call[0] == 'write')
228 self.assertIn("Error in sys.excepthook:", error)
229 self.assertEqual(error.count("not so fast"), 1)
230 self.assertIn("Original exception was:", error)
231 self.assertIn("division by zero", error)
232
233 def test_sysexcepthook_raising_SystemExit_gets_through(self):
234 self.infunc.side_effect = ["1/0"]
235 def raise_base(*args, **kwargs):
236 raise SystemExit
237 self.sysmod.excepthook = raise_base
238 with self.assertRaises(SystemExit):
239 self.console.interact()
240
241 def test_banner(self):
242 # with banner
243 self.infunc.side_effect = EOFError('Finished')
244 self.console.interact(banner='Foo')
245 self.assertEqual(len(self.stderr.method_calls), 3)
246 banner_call = self.stderr.method_calls[0]
247 self.assertEqual(banner_call, ['write', ('Foo\n',), {}])
248
249 # no banner
250 self.stderr.reset_mock()
251 self.infunc.side_effect = EOFError('Finished')
252 self.console.interact(banner='')
253 self.assertEqual(len(self.stderr.method_calls), 2)
254
255 def test_exit_msg(self):
256 # default exit message
257 self.infunc.side_effect = EOFError('Finished')
258 self.console.interact(banner='')
259 self.assertEqual(len(self.stderr.method_calls), 2)
260 err_msg = self.stderr.method_calls[1]
261 expected = 'now exiting InteractiveConsole...\n'
262 self.assertEqual(err_msg, ['write', (expected,), {}])
263
264 # no exit message
265 self.stderr.reset_mock()
266 self.infunc.side_effect = EOFError('Finished')
267 self.console.interact(banner='', exitmsg='')
268 self.assertEqual(len(self.stderr.method_calls), 1)
269
270 # custom exit message
271 self.stderr.reset_mock()
272 message = (
273 'bye! \N{GREEK SMALL LETTER ZETA}\N{CYRILLIC SMALL LETTER ZHE}'
274 )
275 self.infunc.side_effect = EOFError('Finished')
276 self.console.interact(banner='', exitmsg=message)
277 self.assertEqual(len(self.stderr.method_calls), 2)
278 err_msg = self.stderr.method_calls[1]
279 expected = message + '\n'
280 self.assertEqual(err_msg, ['write', (expected,), {}])
281
282
283 def test_cause_tb(self):
284 self.infunc.side_effect = ["raise ValueError('') from AttributeError",
285 EOFError('Finished')]
286 self.console.interact()
287 output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
288 expected = dedent("""
289 AttributeError
290
291 The above exception was the direct cause of the following exception:
292
293 Traceback (most recent call last):
294 File "<console>", line 1, in <module>
295 ValueError
296 """)
297 self.assertIn(expected, output)
298 self.assertIs(self.sysmod.last_type, ValueError)
299 self.assertIs(type(self.sysmod.last_value), ValueError)
300 self.assertIs(self.sysmod.last_traceback, self.sysmod.last_value.__traceback__)
301 self.assertIsNotNone(self.sysmod.last_traceback)
302 self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
303
304 def test_context_tb(self):
305 self.infunc.side_effect = ["try: ham\nexcept: eggs\n",
306 EOFError('Finished')]
307 self.console.interact()
308 output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
309 expected = dedent("""
310 Traceback (most recent call last):
311 File "<console>", line 1, in <module>
312 NameError: name 'ham' is not defined
313
314 During handling of the above exception, another exception occurred:
315
316 Traceback (most recent call last):
317 File "<console>", line 2, in <module>
318 NameError: name 'eggs' is not defined
319 """)
320 self.assertIn(expected, output)
321 self.assertIs(self.sysmod.last_type, NameError)
322 self.assertIs(type(self.sysmod.last_value), NameError)
323 self.assertIs(self.sysmod.last_traceback, self.sysmod.last_value.__traceback__)
324 self.assertIsNotNone(self.sysmod.last_traceback)
325 self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
326
327
328 class TestInteractiveConsoleLocalExit(unittest.TestCase, MockSys):
329
330 def setUp(self):
331 self.console = code.InteractiveConsole(local_exit=True)
332 self.mock_sys()
333
334 @unittest.skipIf(sys.flags.no_site, "exit() isn't defined unless there's a site module")
335 def test_exit(self):
336 # default exit message
337 self.infunc.side_effect = ["exit()"]
338 self.console.interact(banner='')
339 self.assertEqual(len(self.stderr.method_calls), 2)
340 err_msg = self.stderr.method_calls[1]
341 expected = 'now exiting InteractiveConsole...\n'
342 self.assertEqual(err_msg, ['write', (expected,), {}])
343
344
345 if __name__ == "__main__":
346 unittest.main()