##// END OF EJS Templates
Add debugging print for test failure on Windows
Thomas Kluyver -
Show More
@@ -1,490 +1,495 b''
1 """Generic testing tools.
1 """Generic testing tools.
2
2
3 Authors
3 Authors
4 -------
4 -------
5 - Fernando Perez <Fernando.Perez@berkeley.edu>
5 - Fernando Perez <Fernando.Perez@berkeley.edu>
6 """
6 """
7
7
8 from __future__ import absolute_import
8 from __future__ import absolute_import
9
9
10 #-----------------------------------------------------------------------------
10 #-----------------------------------------------------------------------------
11 # Copyright (C) 2009 The IPython Development Team
11 # Copyright (C) 2009 The IPython Development Team
12 #
12 #
13 # Distributed under the terms of the BSD License. The full license is in
13 # Distributed under the terms of the BSD License. The full license is in
14 # the file COPYING, distributed as part of this software.
14 # the file COPYING, distributed as part of this software.
15 #-----------------------------------------------------------------------------
15 #-----------------------------------------------------------------------------
16
16
17 #-----------------------------------------------------------------------------
17 #-----------------------------------------------------------------------------
18 # Imports
18 # Imports
19 #-----------------------------------------------------------------------------
19 #-----------------------------------------------------------------------------
20
20
21 import os
21 import os
22 import re
22 import re
23 import sys
23 import sys
24 import tempfile
24 import tempfile
25
25
26 from contextlib import contextmanager
26 from contextlib import contextmanager
27 from io import StringIO
27 from io import StringIO
28 from subprocess import Popen, PIPE
28 from subprocess import Popen, PIPE
29
29
30 try:
30 try:
31 # These tools are used by parts of the runtime, so we make the nose
31 # These tools are used by parts of the runtime, so we make the nose
32 # dependency optional at this point. Nose is a hard dependency to run the
32 # dependency optional at this point. Nose is a hard dependency to run the
33 # test suite, but NOT to use ipython itself.
33 # test suite, but NOT to use ipython itself.
34 import nose.tools as nt
34 import nose.tools as nt
35 has_nose = True
35 has_nose = True
36 except ImportError:
36 except ImportError:
37 has_nose = False
37 has_nose = False
38
38
39 from IPython.config.loader import Config
39 from IPython.config.loader import Config
40 from IPython.utils.process import get_output_error_code
40 from IPython.utils.process import get_output_error_code
41 from IPython.utils.text import list_strings
41 from IPython.utils.text import list_strings
42 from IPython.utils.io import temp_pyfile, Tee
42 from IPython.utils.io import temp_pyfile, Tee
43 from IPython.utils import py3compat
43 from IPython.utils import py3compat
44 from IPython.utils.encoding import DEFAULT_ENCODING
44 from IPython.utils.encoding import DEFAULT_ENCODING
45
45
46 from . import decorators as dec
46 from . import decorators as dec
47 from . import skipdoctest
47 from . import skipdoctest
48
48
49 #-----------------------------------------------------------------------------
49 #-----------------------------------------------------------------------------
50 # Functions and classes
50 # Functions and classes
51 #-----------------------------------------------------------------------------
51 #-----------------------------------------------------------------------------
52
52
53 # The docstring for full_path doctests differently on win32 (different path
53 # The docstring for full_path doctests differently on win32 (different path
54 # separator) so just skip the doctest there. The example remains informative.
54 # separator) so just skip the doctest there. The example remains informative.
55 doctest_deco = skipdoctest.skip_doctest if sys.platform == 'win32' else dec.null_deco
55 doctest_deco = skipdoctest.skip_doctest if sys.platform == 'win32' else dec.null_deco
56
56
57 @doctest_deco
57 @doctest_deco
58 def full_path(startPath,files):
58 def full_path(startPath,files):
59 """Make full paths for all the listed files, based on startPath.
59 """Make full paths for all the listed files, based on startPath.
60
60
61 Only the base part of startPath is kept, since this routine is typically
61 Only the base part of startPath is kept, since this routine is typically
62 used with a script's ``__file__`` variable as startPath. The base of startPath
62 used with a script's ``__file__`` variable as startPath. The base of startPath
63 is then prepended to all the listed files, forming the output list.
63 is then prepended to all the listed files, forming the output list.
64
64
65 Parameters
65 Parameters
66 ----------
66 ----------
67 startPath : string
67 startPath : string
68 Initial path to use as the base for the results. This path is split
68 Initial path to use as the base for the results. This path is split
69 using os.path.split() and only its first component is kept.
69 using os.path.split() and only its first component is kept.
70
70
71 files : string or list
71 files : string or list
72 One or more files.
72 One or more files.
73
73
74 Examples
74 Examples
75 --------
75 --------
76
76
77 >>> full_path('/foo/bar.py',['a.txt','b.txt'])
77 >>> full_path('/foo/bar.py',['a.txt','b.txt'])
78 ['/foo/a.txt', '/foo/b.txt']
78 ['/foo/a.txt', '/foo/b.txt']
79
79
80 >>> full_path('/foo',['a.txt','b.txt'])
80 >>> full_path('/foo',['a.txt','b.txt'])
81 ['/a.txt', '/b.txt']
81 ['/a.txt', '/b.txt']
82
82
83 If a single file is given, the output is still a list::
83 If a single file is given, the output is still a list::
84
84
85 >>> full_path('/foo','a.txt')
85 >>> full_path('/foo','a.txt')
86 ['/a.txt']
86 ['/a.txt']
87 """
87 """
88
88
89 files = list_strings(files)
89 files = list_strings(files)
90 base = os.path.split(startPath)[0]
90 base = os.path.split(startPath)[0]
91 return [ os.path.join(base,f) for f in files ]
91 return [ os.path.join(base,f) for f in files ]
92
92
93
93
94 def parse_test_output(txt):
94 def parse_test_output(txt):
95 """Parse the output of a test run and return errors, failures.
95 """Parse the output of a test run and return errors, failures.
96
96
97 Parameters
97 Parameters
98 ----------
98 ----------
99 txt : str
99 txt : str
100 Text output of a test run, assumed to contain a line of one of the
100 Text output of a test run, assumed to contain a line of one of the
101 following forms::
101 following forms::
102
102
103 'FAILED (errors=1)'
103 'FAILED (errors=1)'
104 'FAILED (failures=1)'
104 'FAILED (failures=1)'
105 'FAILED (errors=1, failures=1)'
105 'FAILED (errors=1, failures=1)'
106
106
107 Returns
107 Returns
108 -------
108 -------
109 nerr, nfail
109 nerr, nfail
110 number of errors and failures.
110 number of errors and failures.
111 """
111 """
112
112
113 err_m = re.search(r'^FAILED \(errors=(\d+)\)', txt, re.MULTILINE)
113 err_m = re.search(r'^FAILED \(errors=(\d+)\)', txt, re.MULTILINE)
114 if err_m:
114 if err_m:
115 nerr = int(err_m.group(1))
115 nerr = int(err_m.group(1))
116 nfail = 0
116 nfail = 0
117 return nerr, nfail
117 return nerr, nfail
118
118
119 fail_m = re.search(r'^FAILED \(failures=(\d+)\)', txt, re.MULTILINE)
119 fail_m = re.search(r'^FAILED \(failures=(\d+)\)', txt, re.MULTILINE)
120 if fail_m:
120 if fail_m:
121 nerr = 0
121 nerr = 0
122 nfail = int(fail_m.group(1))
122 nfail = int(fail_m.group(1))
123 return nerr, nfail
123 return nerr, nfail
124
124
125 both_m = re.search(r'^FAILED \(errors=(\d+), failures=(\d+)\)', txt,
125 both_m = re.search(r'^FAILED \(errors=(\d+), failures=(\d+)\)', txt,
126 re.MULTILINE)
126 re.MULTILINE)
127 if both_m:
127 if both_m:
128 nerr = int(both_m.group(1))
128 nerr = int(both_m.group(1))
129 nfail = int(both_m.group(2))
129 nfail = int(both_m.group(2))
130 return nerr, nfail
130 return nerr, nfail
131
131
132 # If the input didn't match any of these forms, assume no error/failures
132 # If the input didn't match any of these forms, assume no error/failures
133 return 0, 0
133 return 0, 0
134
134
135
135
136 # So nose doesn't think this is a test
136 # So nose doesn't think this is a test
137 parse_test_output.__test__ = False
137 parse_test_output.__test__ = False
138
138
139
139
140 def default_argv():
140 def default_argv():
141 """Return a valid default argv for creating testing instances of ipython"""
141 """Return a valid default argv for creating testing instances of ipython"""
142
142
143 return ['--quick', # so no config file is loaded
143 return ['--quick', # so no config file is loaded
144 # Other defaults to minimize side effects on stdout
144 # Other defaults to minimize side effects on stdout
145 '--colors=NoColor', '--no-term-title','--no-banner',
145 '--colors=NoColor', '--no-term-title','--no-banner',
146 '--autocall=0']
146 '--autocall=0']
147
147
148
148
149 def default_config():
149 def default_config():
150 """Return a config object with good defaults for testing."""
150 """Return a config object with good defaults for testing."""
151 config = Config()
151 config = Config()
152 config.TerminalInteractiveShell.colors = 'NoColor'
152 config.TerminalInteractiveShell.colors = 'NoColor'
153 config.TerminalTerminalInteractiveShell.term_title = False,
153 config.TerminalTerminalInteractiveShell.term_title = False,
154 config.TerminalInteractiveShell.autocall = 0
154 config.TerminalInteractiveShell.autocall = 0
155 f = tempfile.NamedTemporaryFile(suffix=u'test_hist.sqlite', delete=False)
155 f = tempfile.NamedTemporaryFile(suffix=u'test_hist.sqlite', delete=False)
156 config.HistoryManager.hist_file = f.name
156 config.HistoryManager.hist_file = f.name
157 f.close()
157 f.close()
158 config.HistoryManager.db_cache_size = 10000
158 config.HistoryManager.db_cache_size = 10000
159 return config
159 return config
160
160
161
161
162 def get_ipython_cmd(as_string=False):
162 def get_ipython_cmd(as_string=False):
163 """
163 """
164 Return appropriate IPython command line name. By default, this will return
164 Return appropriate IPython command line name. By default, this will return
165 a list that can be used with subprocess.Popen, for example, but passing
165 a list that can be used with subprocess.Popen, for example, but passing
166 `as_string=True` allows for returning the IPython command as a string.
166 `as_string=True` allows for returning the IPython command as a string.
167
167
168 Parameters
168 Parameters
169 ----------
169 ----------
170 as_string: bool
170 as_string: bool
171 Flag to allow to return the command as a string.
171 Flag to allow to return the command as a string.
172 """
172 """
173 ipython_cmd = [sys.executable, "-m", "IPython"]
173 ipython_cmd = [sys.executable, "-m", "IPython"]
174
174
175 if as_string:
175 if as_string:
176 ipython_cmd = " ".join(ipython_cmd)
176 ipython_cmd = " ".join(ipython_cmd)
177
177
178 return ipython_cmd
178 return ipython_cmd
179
179
180 def ipexec(fname, options=None, commands=()):
180 def ipexec(fname, options=None, commands=()):
181 """Utility to call 'ipython filename'.
181 """Utility to call 'ipython filename'.
182
182
183 Starts IPython with a minimal and safe configuration to make startup as fast
183 Starts IPython with a minimal and safe configuration to make startup as fast
184 as possible.
184 as possible.
185
185
186 Note that this starts IPython in a subprocess!
186 Note that this starts IPython in a subprocess!
187
187
188 Parameters
188 Parameters
189 ----------
189 ----------
190 fname : str
190 fname : str
191 Name of file to be executed (should have .py or .ipy extension).
191 Name of file to be executed (should have .py or .ipy extension).
192
192
193 options : optional, list
193 options : optional, list
194 Extra command-line flags to be passed to IPython.
194 Extra command-line flags to be passed to IPython.
195
195
196 commands : optional, list
196 commands : optional, list
197 Commands to send in on stdin
197 Commands to send in on stdin
198
198
199 Returns
199 Returns
200 -------
200 -------
201 (stdout, stderr) of ipython subprocess.
201 (stdout, stderr) of ipython subprocess.
202 """
202 """
203 if options is None: options = []
203 if options is None: options = []
204
204
205 # For these subprocess calls, eliminate all prompt printing so we only see
205 # For these subprocess calls, eliminate all prompt printing so we only see
206 # output from script execution
206 # output from script execution
207 prompt_opts = [ '--PromptManager.in_template=""',
207 prompt_opts = [ '--PromptManager.in_template=""',
208 '--PromptManager.in2_template=""',
208 '--PromptManager.in2_template=""',
209 '--PromptManager.out_template=""'
209 '--PromptManager.out_template=""'
210 ]
210 ]
211 cmdargs = default_argv() + prompt_opts + options
211 cmdargs = default_argv() + prompt_opts + options
212
212
213 test_dir = os.path.dirname(__file__)
213 test_dir = os.path.dirname(__file__)
214
214
215 ipython_cmd = get_ipython_cmd()
215 ipython_cmd = get_ipython_cmd()
216 # Absolute path for filename
216 # Absolute path for filename
217 full_fname = os.path.join(test_dir, fname)
217 full_fname = os.path.join(test_dir, fname)
218 full_cmd = ipython_cmd + cmdargs + [full_fname]
218 full_cmd = ipython_cmd + cmdargs + [full_fname]
219 env = os.environ.copy()
219 env = os.environ.copy()
220 env.pop('PYTHONWARNINGS', None) # Avoid extraneous warnings appearing on stderr
220 env.pop('PYTHONWARNINGS', None) # Avoid extraneous warnings appearing on stderr
221 for k, v in env.items():
222 # Debug a bizarre failure we've seen on Windows:
223 # TypeError: environment can only contain strings
224 if not isinstance(v, str):
225 print(v)
221 p = Popen(full_cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE, env=env)
226 p = Popen(full_cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE, env=env)
222 out, err = p.communicate(input=py3compat.str_to_bytes('\n'.join(commands)) or None)
227 out, err = p.communicate(input=py3compat.str_to_bytes('\n'.join(commands)) or None)
223 out, err = py3compat.bytes_to_str(out), py3compat.bytes_to_str(err)
228 out, err = py3compat.bytes_to_str(out), py3compat.bytes_to_str(err)
224 # `import readline` causes 'ESC[?1034h' to be output sometimes,
229 # `import readline` causes 'ESC[?1034h' to be output sometimes,
225 # so strip that out before doing comparisons
230 # so strip that out before doing comparisons
226 if out:
231 if out:
227 out = re.sub(r'\x1b\[[^h]+h', '', out)
232 out = re.sub(r'\x1b\[[^h]+h', '', out)
228 return out, err
233 return out, err
229
234
230
235
231 def ipexec_validate(fname, expected_out, expected_err='',
236 def ipexec_validate(fname, expected_out, expected_err='',
232 options=None, commands=()):
237 options=None, commands=()):
233 """Utility to call 'ipython filename' and validate output/error.
238 """Utility to call 'ipython filename' and validate output/error.
234
239
235 This function raises an AssertionError if the validation fails.
240 This function raises an AssertionError if the validation fails.
236
241
237 Note that this starts IPython in a subprocess!
242 Note that this starts IPython in a subprocess!
238
243
239 Parameters
244 Parameters
240 ----------
245 ----------
241 fname : str
246 fname : str
242 Name of the file to be executed (should have .py or .ipy extension).
247 Name of the file to be executed (should have .py or .ipy extension).
243
248
244 expected_out : str
249 expected_out : str
245 Expected stdout of the process.
250 Expected stdout of the process.
246
251
247 expected_err : optional, str
252 expected_err : optional, str
248 Expected stderr of the process.
253 Expected stderr of the process.
249
254
250 options : optional, list
255 options : optional, list
251 Extra command-line flags to be passed to IPython.
256 Extra command-line flags to be passed to IPython.
252
257
253 Returns
258 Returns
254 -------
259 -------
255 None
260 None
256 """
261 """
257
262
258 import nose.tools as nt
263 import nose.tools as nt
259
264
260 out, err = ipexec(fname, options, commands)
265 out, err = ipexec(fname, options, commands)
261 #print 'OUT', out # dbg
266 #print 'OUT', out # dbg
262 #print 'ERR', err # dbg
267 #print 'ERR', err # dbg
263 # If there are any errors, we must check those befor stdout, as they may be
268 # If there are any errors, we must check those befor stdout, as they may be
264 # more informative than simply having an empty stdout.
269 # more informative than simply having an empty stdout.
265 if err:
270 if err:
266 if expected_err:
271 if expected_err:
267 nt.assert_equal("\n".join(err.strip().splitlines()), "\n".join(expected_err.strip().splitlines()))
272 nt.assert_equal("\n".join(err.strip().splitlines()), "\n".join(expected_err.strip().splitlines()))
268 else:
273 else:
269 raise ValueError('Running file %r produced error: %r' %
274 raise ValueError('Running file %r produced error: %r' %
270 (fname, err))
275 (fname, err))
271 # If no errors or output on stderr was expected, match stdout
276 # If no errors or output on stderr was expected, match stdout
272 nt.assert_equal("\n".join(out.strip().splitlines()), "\n".join(expected_out.strip().splitlines()))
277 nt.assert_equal("\n".join(out.strip().splitlines()), "\n".join(expected_out.strip().splitlines()))
273
278
274
279
275 class TempFileMixin(object):
280 class TempFileMixin(object):
276 """Utility class to create temporary Python/IPython files.
281 """Utility class to create temporary Python/IPython files.
277
282
278 Meant as a mixin class for test cases."""
283 Meant as a mixin class for test cases."""
279
284
280 def mktmp(self, src, ext='.py'):
285 def mktmp(self, src, ext='.py'):
281 """Make a valid python temp file."""
286 """Make a valid python temp file."""
282 fname, f = temp_pyfile(src, ext)
287 fname, f = temp_pyfile(src, ext)
283 self.tmpfile = f
288 self.tmpfile = f
284 self.fname = fname
289 self.fname = fname
285
290
286 def tearDown(self):
291 def tearDown(self):
287 if hasattr(self, 'tmpfile'):
292 if hasattr(self, 'tmpfile'):
288 # If the tmpfile wasn't made because of skipped tests, like in
293 # If the tmpfile wasn't made because of skipped tests, like in
289 # win32, there's nothing to cleanup.
294 # win32, there's nothing to cleanup.
290 self.tmpfile.close()
295 self.tmpfile.close()
291 try:
296 try:
292 os.unlink(self.fname)
297 os.unlink(self.fname)
293 except:
298 except:
294 # On Windows, even though we close the file, we still can't
299 # On Windows, even though we close the file, we still can't
295 # delete it. I have no clue why
300 # delete it. I have no clue why
296 pass
301 pass
297
302
298 pair_fail_msg = ("Testing {0}\n\n"
303 pair_fail_msg = ("Testing {0}\n\n"
299 "In:\n"
304 "In:\n"
300 " {1!r}\n"
305 " {1!r}\n"
301 "Expected:\n"
306 "Expected:\n"
302 " {2!r}\n"
307 " {2!r}\n"
303 "Got:\n"
308 "Got:\n"
304 " {3!r}\n")
309 " {3!r}\n")
305 def check_pairs(func, pairs):
310 def check_pairs(func, pairs):
306 """Utility function for the common case of checking a function with a
311 """Utility function for the common case of checking a function with a
307 sequence of input/output pairs.
312 sequence of input/output pairs.
308
313
309 Parameters
314 Parameters
310 ----------
315 ----------
311 func : callable
316 func : callable
312 The function to be tested. Should accept a single argument.
317 The function to be tested. Should accept a single argument.
313 pairs : iterable
318 pairs : iterable
314 A list of (input, expected_output) tuples.
319 A list of (input, expected_output) tuples.
315
320
316 Returns
321 Returns
317 -------
322 -------
318 None. Raises an AssertionError if any output does not match the expected
323 None. Raises an AssertionError if any output does not match the expected
319 value.
324 value.
320 """
325 """
321 name = getattr(func, "func_name", getattr(func, "__name__", "<unknown>"))
326 name = getattr(func, "func_name", getattr(func, "__name__", "<unknown>"))
322 for inp, expected in pairs:
327 for inp, expected in pairs:
323 out = func(inp)
328 out = func(inp)
324 assert out == expected, pair_fail_msg.format(name, inp, expected, out)
329 assert out == expected, pair_fail_msg.format(name, inp, expected, out)
325
330
326
331
327 if py3compat.PY3:
332 if py3compat.PY3:
328 MyStringIO = StringIO
333 MyStringIO = StringIO
329 else:
334 else:
330 # In Python 2, stdout/stderr can have either bytes or unicode written to them,
335 # In Python 2, stdout/stderr can have either bytes or unicode written to them,
331 # so we need a class that can handle both.
336 # so we need a class that can handle both.
332 class MyStringIO(StringIO):
337 class MyStringIO(StringIO):
333 def write(self, s):
338 def write(self, s):
334 s = py3compat.cast_unicode(s, encoding=DEFAULT_ENCODING)
339 s = py3compat.cast_unicode(s, encoding=DEFAULT_ENCODING)
335 super(MyStringIO, self).write(s)
340 super(MyStringIO, self).write(s)
336
341
337 _re_type = type(re.compile(r''))
342 _re_type = type(re.compile(r''))
338
343
339 notprinted_msg = """Did not find {0!r} in printed output (on {1}):
344 notprinted_msg = """Did not find {0!r} in printed output (on {1}):
340 -------
345 -------
341 {2!s}
346 {2!s}
342 -------
347 -------
343 """
348 """
344
349
345 class AssertPrints(object):
350 class AssertPrints(object):
346 """Context manager for testing that code prints certain text.
351 """Context manager for testing that code prints certain text.
347
352
348 Examples
353 Examples
349 --------
354 --------
350 >>> with AssertPrints("abc", suppress=False):
355 >>> with AssertPrints("abc", suppress=False):
351 ... print("abcd")
356 ... print("abcd")
352 ... print("def")
357 ... print("def")
353 ...
358 ...
354 abcd
359 abcd
355 def
360 def
356 """
361 """
357 def __init__(self, s, channel='stdout', suppress=True):
362 def __init__(self, s, channel='stdout', suppress=True):
358 self.s = s
363 self.s = s
359 if isinstance(self.s, (py3compat.string_types, _re_type)):
364 if isinstance(self.s, (py3compat.string_types, _re_type)):
360 self.s = [self.s]
365 self.s = [self.s]
361 self.channel = channel
366 self.channel = channel
362 self.suppress = suppress
367 self.suppress = suppress
363
368
364 def __enter__(self):
369 def __enter__(self):
365 self.orig_stream = getattr(sys, self.channel)
370 self.orig_stream = getattr(sys, self.channel)
366 self.buffer = MyStringIO()
371 self.buffer = MyStringIO()
367 self.tee = Tee(self.buffer, channel=self.channel)
372 self.tee = Tee(self.buffer, channel=self.channel)
368 setattr(sys, self.channel, self.buffer if self.suppress else self.tee)
373 setattr(sys, self.channel, self.buffer if self.suppress else self.tee)
369
374
370 def __exit__(self, etype, value, traceback):
375 def __exit__(self, etype, value, traceback):
371 try:
376 try:
372 if value is not None:
377 if value is not None:
373 # If an error was raised, don't check anything else
378 # If an error was raised, don't check anything else
374 return False
379 return False
375 self.tee.flush()
380 self.tee.flush()
376 setattr(sys, self.channel, self.orig_stream)
381 setattr(sys, self.channel, self.orig_stream)
377 printed = self.buffer.getvalue()
382 printed = self.buffer.getvalue()
378 for s in self.s:
383 for s in self.s:
379 if isinstance(s, _re_type):
384 if isinstance(s, _re_type):
380 assert s.search(printed), notprinted_msg.format(s.pattern, self.channel, printed)
385 assert s.search(printed), notprinted_msg.format(s.pattern, self.channel, printed)
381 else:
386 else:
382 assert s in printed, notprinted_msg.format(s, self.channel, printed)
387 assert s in printed, notprinted_msg.format(s, self.channel, printed)
383 return False
388 return False
384 finally:
389 finally:
385 self.tee.close()
390 self.tee.close()
386
391
387 printed_msg = """Found {0!r} in printed output (on {1}):
392 printed_msg = """Found {0!r} in printed output (on {1}):
388 -------
393 -------
389 {2!s}
394 {2!s}
390 -------
395 -------
391 """
396 """
392
397
393 class AssertNotPrints(AssertPrints):
398 class AssertNotPrints(AssertPrints):
394 """Context manager for checking that certain output *isn't* produced.
399 """Context manager for checking that certain output *isn't* produced.
395
400
396 Counterpart of AssertPrints"""
401 Counterpart of AssertPrints"""
397 def __exit__(self, etype, value, traceback):
402 def __exit__(self, etype, value, traceback):
398 try:
403 try:
399 if value is not None:
404 if value is not None:
400 # If an error was raised, don't check anything else
405 # If an error was raised, don't check anything else
401 self.tee.close()
406 self.tee.close()
402 return False
407 return False
403 self.tee.flush()
408 self.tee.flush()
404 setattr(sys, self.channel, self.orig_stream)
409 setattr(sys, self.channel, self.orig_stream)
405 printed = self.buffer.getvalue()
410 printed = self.buffer.getvalue()
406 for s in self.s:
411 for s in self.s:
407 if isinstance(s, _re_type):
412 if isinstance(s, _re_type):
408 assert not s.search(printed),printed_msg.format(
413 assert not s.search(printed),printed_msg.format(
409 s.pattern, self.channel, printed)
414 s.pattern, self.channel, printed)
410 else:
415 else:
411 assert s not in printed, printed_msg.format(
416 assert s not in printed, printed_msg.format(
412 s, self.channel, printed)
417 s, self.channel, printed)
413 return False
418 return False
414 finally:
419 finally:
415 self.tee.close()
420 self.tee.close()
416
421
417 @contextmanager
422 @contextmanager
418 def mute_warn():
423 def mute_warn():
419 from IPython.utils import warn
424 from IPython.utils import warn
420 save_warn = warn.warn
425 save_warn = warn.warn
421 warn.warn = lambda *a, **kw: None
426 warn.warn = lambda *a, **kw: None
422 try:
427 try:
423 yield
428 yield
424 finally:
429 finally:
425 warn.warn = save_warn
430 warn.warn = save_warn
426
431
427 @contextmanager
432 @contextmanager
428 def make_tempfile(name):
433 def make_tempfile(name):
429 """ Create an empty, named, temporary file for the duration of the context.
434 """ Create an empty, named, temporary file for the duration of the context.
430 """
435 """
431 f = open(name, 'w')
436 f = open(name, 'w')
432 f.close()
437 f.close()
433 try:
438 try:
434 yield
439 yield
435 finally:
440 finally:
436 os.unlink(name)
441 os.unlink(name)
437
442
438
443
439 @contextmanager
444 @contextmanager
440 def monkeypatch(obj, name, attr):
445 def monkeypatch(obj, name, attr):
441 """
446 """
442 Context manager to replace attribute named `name` in `obj` with `attr`.
447 Context manager to replace attribute named `name` in `obj` with `attr`.
443 """
448 """
444 orig = getattr(obj, name)
449 orig = getattr(obj, name)
445 setattr(obj, name, attr)
450 setattr(obj, name, attr)
446 yield
451 yield
447 setattr(obj, name, orig)
452 setattr(obj, name, orig)
448
453
449
454
450 def help_output_test(subcommand=''):
455 def help_output_test(subcommand=''):
451 """test that `ipython [subcommand] -h` works"""
456 """test that `ipython [subcommand] -h` works"""
452 cmd = get_ipython_cmd() + [subcommand, '-h']
457 cmd = get_ipython_cmd() + [subcommand, '-h']
453 out, err, rc = get_output_error_code(cmd)
458 out, err, rc = get_output_error_code(cmd)
454 nt.assert_equal(rc, 0, err)
459 nt.assert_equal(rc, 0, err)
455 nt.assert_not_in("Traceback", err)
460 nt.assert_not_in("Traceback", err)
456 nt.assert_in("Options", out)
461 nt.assert_in("Options", out)
457 nt.assert_in("--help-all", out)
462 nt.assert_in("--help-all", out)
458 return out, err
463 return out, err
459
464
460
465
461 def help_all_output_test(subcommand=''):
466 def help_all_output_test(subcommand=''):
462 """test that `ipython [subcommand] --help-all` works"""
467 """test that `ipython [subcommand] --help-all` works"""
463 cmd = get_ipython_cmd() + [subcommand, '--help-all']
468 cmd = get_ipython_cmd() + [subcommand, '--help-all']
464 out, err, rc = get_output_error_code(cmd)
469 out, err, rc = get_output_error_code(cmd)
465 nt.assert_equal(rc, 0, err)
470 nt.assert_equal(rc, 0, err)
466 nt.assert_not_in("Traceback", err)
471 nt.assert_not_in("Traceback", err)
467 nt.assert_in("Options", out)
472 nt.assert_in("Options", out)
468 nt.assert_in("Class parameters", out)
473 nt.assert_in("Class parameters", out)
469 return out, err
474 return out, err
470
475
471 def assert_big_text_equal(a, b, chunk_size=80):
476 def assert_big_text_equal(a, b, chunk_size=80):
472 """assert that large strings are equal
477 """assert that large strings are equal
473
478
474 Zooms in on first chunk that differs,
479 Zooms in on first chunk that differs,
475 to give better info than vanilla assertEqual for large text blobs.
480 to give better info than vanilla assertEqual for large text blobs.
476 """
481 """
477 for i in range(0, len(a), chunk_size):
482 for i in range(0, len(a), chunk_size):
478 chunk_a = a[i:i + chunk_size]
483 chunk_a = a[i:i + chunk_size]
479 chunk_b = b[i:i + chunk_size]
484 chunk_b = b[i:i + chunk_size]
480 nt.assert_equal(chunk_a, chunk_b, "[offset: %i]\n%r != \n%r" % (
485 nt.assert_equal(chunk_a, chunk_b, "[offset: %i]\n%r != \n%r" % (
481 i, chunk_a, chunk_b))
486 i, chunk_a, chunk_b))
482
487
483 if len(a) > len(b):
488 if len(a) > len(b):
484 nt.fail("Length doesn't match (%i > %i). Extra text:\n%r" % (
489 nt.fail("Length doesn't match (%i > %i). Extra text:\n%r" % (
485 len(a), len(b), a[len(b):]
490 len(a), len(b), a[len(b):]
486 ))
491 ))
487 elif len(a) < len(b):
492 elif len(a) < len(b):
488 nt.fail("Length doesn't match (%i < %i). Extra text:\n%r" % (
493 nt.fail("Length doesn't match (%i < %i). Extra text:\n%r" % (
489 len(a), len(b), b[len(a):]
494 len(a), len(b), b[len(a):]
490 ))
495 ))
General Comments 0
You need to be logged in to leave comments. Login now