test_prefilter.py
381 lines
| 12.6 KiB
| text/x-python
|
PythonLexer
/ test / test_prefilter.py
fperez
|
r532 | """ | ||
Test which prefilter transformations get called for various input lines. | ||||
Note that this does *not* test the transformations themselves -- it's just | ||||
verifying that a particular combination of, e.g. config options and escape | ||||
chars trigger the proper handle_X transform of the input line. | ||||
Usage: run from the command line with *normal* python, not ipython: | ||||
> python test_prefilter.py | ||||
Fairly quiet output by default. Pass in -v to get everyone's favorite dots. | ||||
""" | ||||
# The prefilter always ends in a call to some self.handle_X method. We swap | ||||
# all of those out so that we can capture which one was called. | ||||
import sys | ||||
import IPython | ||||
import IPython.ipapi | ||||
import sys | ||||
verbose = False | ||||
if len(sys.argv) > 1: | ||||
if sys.argv[1] == '-v': | ||||
sys.argv = sys.argv[:-1] # IPython is confused by -v, apparently | ||||
verbose = True | ||||
IPython.Shell.start() | ||||
ip = IPython.ipapi.get() | ||||
# Collect failed tests + stats and print them at the end | ||||
failures = [] | ||||
num_tests = 0 | ||||
# Store the results in module vars as we go | ||||
last_line = None | ||||
handler_called = None | ||||
def install_mock_handler(name): | ||||
"""Swap out one of the IP.handle_x methods with a function which can | ||||
record which handler was called and what line was produced. The mock | ||||
handler func always returns '', which causes ipython to cease handling | ||||
the string immediately. That way, that it doesn't echo output, raise | ||||
exceptions, etc. But do note that testing multiline strings thus gets | ||||
a bit hard.""" | ||||
def mock_handler(self, line, continue_prompt=None, | ||||
pre=None,iFun=None,theRest=None, | ||||
obj=None): | ||||
#print "Inside %s with '%s'" % (name, line) | ||||
global last_line, handler_called | ||||
last_line = line | ||||
handler_called = name | ||||
return '' | ||||
mock_handler.name = name | ||||
setattr(IPython.iplib.InteractiveShell, name, mock_handler) | ||||
install_mock_handler('handle_normal') | ||||
install_mock_handler('handle_auto') | ||||
install_mock_handler('handle_magic') | ||||
install_mock_handler('handle_help') | ||||
install_mock_handler('handle_shell_escape') | ||||
install_mock_handler('handle_alias') | ||||
install_mock_handler('handle_emacs') | ||||
def reset_esc_handlers(): | ||||
"""The escape handlers are stored in a hash (as an attribute of the | ||||
InteractiveShell *instance*), so we have to rebuild that hash to get our | ||||
new handlers in there.""" | ||||
s = ip.IP | ||||
s.esc_handlers = {s.ESC_PAREN : s.handle_auto, | ||||
s.ESC_QUOTE : s.handle_auto, | ||||
s.ESC_QUOTE2 : s.handle_auto, | ||||
s.ESC_MAGIC : s.handle_magic, | ||||
s.ESC_HELP : s.handle_help, | ||||
s.ESC_SHELL : s.handle_shell_escape, | ||||
} | ||||
reset_esc_handlers() | ||||
# This is so I don't have to quote over and over. Gotta be a better way. | ||||
handle_normal = 'handle_normal' | ||||
handle_auto = 'handle_auto' | ||||
handle_magic = 'handle_magic' | ||||
handle_help = 'handle_help' | ||||
handle_shell_escape = 'handle_shell_escape' | ||||
handle_alias = 'handle_alias' | ||||
handle_emacs = 'handle_emacs' | ||||
def check(assertion, failure_msg): | ||||
"""Check a boolean assertion and fail with a message if necessary. Store | ||||
an error essage in module-level failures list in case of failure. Print | ||||
'.' or 'F' if module var Verbose is true. | ||||
""" | ||||
global num_tests | ||||
num_tests += 1 | ||||
if assertion: | ||||
if verbose: | ||||
sys.stdout.write('.') | ||||
sys.stdout.flush() | ||||
else: | ||||
if verbose: | ||||
sys.stdout.write('F') | ||||
sys.stdout.flush() | ||||
failures.append(failure_msg) | ||||
def check_handler(expected_handler, line): | ||||
"""Verify that the expected hander was called (for the given line, | ||||
passed in for failure reporting). | ||||
Pulled out to its own function so that tests which don't use | ||||
run_handler_tests can still take advantage of it.""" | ||||
check(handler_called == expected_handler, | ||||
"Expected %s to be called for %s, " | ||||
"instead %s called" % (expected_handler, | ||||
repr(line), | ||||
handler_called)) | ||||
def run_handler_tests(h_tests): | ||||
"""Loop through a series of (input_line, handler_name) pairs, verifying | ||||
that, for each ip calls the given handler for the given line. | ||||
The verbose complaint includes the line passed in, so if that line can | ||||
include enough info to find the error, the tests are modestly | ||||
self-documenting. | ||||
""" | ||||
for ln, expected_handler in h_tests: | ||||
global handler_called | ||||
handler_called = None | ||||
ip.runlines(ln) | ||||
check_handler(expected_handler, ln) | ||||
def run_one_test(ln, expected_handler): | ||||
run_handler_tests([(ln, expected_handler)]) | ||||
# ========================================= | ||||
# Tests | ||||
# ========================================= | ||||
# Fundamental escape characters + whitespace & misc | ||||
# ================================================= | ||||
esc_handler_tests = [ | ||||
( '?thing', handle_help, ), | ||||
( 'thing?', handle_help ), # '?' can trail... | ||||
( 'thing!', handle_normal), # but only '?' can trail | ||||
( '!thing?', handle_help), # trailing '?' wins if more than one | ||||
( ' ?thing', handle_help), # ignore leading whitespace | ||||
( '!ls', handle_shell_escape ), | ||||
( '%magic', handle_magic), | ||||
# Possibly, add test for /,; once those are unhooked from %autocall | ||||
( 'emacs_mode # PYTHON-MODE', handle_emacs ), | ||||
( ' ', handle_normal), | ||||
] | ||||
run_handler_tests(esc_handler_tests) | ||||
# Shell Escapes in Multi-line statements | ||||
# ====================================== | ||||
# | ||||
# We can't test this via runlines, since the hacked over-handlers all | ||||
# return None, so continue_prompt never becomes true. Instead we drop | ||||
# into prefilter directly and pass in continue_prompt. | ||||
old_mls = ip.options.multi_line_specials | ||||
ln = '!ls $f multi_line_specials on' | ||||
ignore = ip.IP.prefilter(ln, continue_prompt=True) | ||||
check_handler(handle_shell_escape, ln) | ||||
ip.options.multi_line_specials = 0 | ||||
ln = '!ls $f multi_line_specials off' | ||||
ignore = ip.IP.prefilter(ln, continue_prompt=True) | ||||
check_handler(handle_normal, ln) | ||||
ip.options.multi_line_specials = old_mls | ||||
# Automagic | ||||
# ========= | ||||
# Pick one magic fun and one non_magic fun, make sure both exist | ||||
assert hasattr(ip.IP, "magic_cpaste") | ||||
assert not hasattr(ip.IP, "magic_does_not_exist") | ||||
ip.options.automagic = 0 | ||||
run_handler_tests([ | ||||
# Without automagic, only shows up with explicit escape | ||||
( 'cpaste', handle_normal), | ||||
( '%cpaste', handle_magic), | ||||
( '%does_not_exist', handle_magic) | ||||
]) | ||||
ip.options.automagic = 1 | ||||
run_handler_tests([ | ||||
( 'cpaste', handle_magic), | ||||
( '%cpaste', handle_magic), | ||||
( 'does_not_exist', handle_normal), | ||||
( '%does_not_exist', handle_magic)]) | ||||
# If next elt starts with anything that could be an assignment, func call, | ||||
# etc, we don't call the magic func, unless explicitly escaped to do so. | ||||
magic_killing_tests = [] | ||||
for c in list('!=()<>,'): | ||||
magic_killing_tests.append(('cpaste %s killed_automagic' % c, handle_normal)) | ||||
magic_killing_tests.append(('%%cpaste %s escaped_magic' % c, handle_magic)) | ||||
run_handler_tests(magic_killing_tests) | ||||
# magic on indented continuation lines -- on iff multi_line_specials == 1 | ||||
ip.options.multi_line_specials = 0 | ||||
ln = 'cpaste multi_line off kills magic' | ||||
ignore = ip.IP.prefilter(ln, continue_prompt=True) | ||||
check_handler(handle_normal, ln) | ||||
ip.options.multi_line_specials = 1 | ||||
ln = 'cpaste multi_line on enables magic' | ||||
ignore = ip.IP.prefilter(ln, continue_prompt=True) | ||||
check_handler(handle_magic, ln) | ||||
# user namespace shadows the magic one unless shell escaped | ||||
ip.user_ns['cpaste'] = 'user_ns' | ||||
run_handler_tests([ | ||||
( 'cpaste', handle_normal), | ||||
( '%cpaste', handle_magic)]) | ||||
del ip.user_ns['cpaste'] | ||||
# Check for !=() turning off .ofind | ||||
# ================================= | ||||
class AttributeMutator(object): | ||||
"""A class which will be modified on attribute access, to test ofind""" | ||||
def __init__(self): | ||||
self.called = False | ||||
def getFoo(self): self.called = True | ||||
foo = property(getFoo) | ||||
attr_mutator = AttributeMutator() | ||||
ip.to_user_ns('attr_mutator') | ||||
ip.options.autocall = 1 | ||||
run_one_test('attr_mutator.foo should mutate', handle_normal) | ||||
check(attr_mutator.called, 'ofind should be called in absence of assign characters') | ||||
for c in list('!=()'): # XXX What about <> -- they *are* important above | ||||
attr_mutator.called = False | ||||
run_one_test('attr_mutator.foo %s should *not* mutate' % c, handle_normal) | ||||
check(not attr_mutator.called, | ||||
'ofind should not be called near character %s' % c) | ||||
# Alias expansion | ||||
# =============== | ||||
# With autocall on or off, aliases should be shadowed by user, internal and | ||||
# __builtin__ namespaces | ||||
# | ||||
# XXX Can aliases have '.' in their name? With autocall off, that works, | ||||
# with autocall on, it doesn't. Hmmm. | ||||
import __builtin__ | ||||
for ac_state in [0,1]: | ||||
ip.options.autocall = ac_state | ||||
ip.IP.alias_table['alias_cmd'] = 'alias_result' | ||||
ip.IP.alias_table['alias_head.with_dot'] = 'alias_result' | ||||
run_handler_tests([ | ||||
("alias_cmd", handle_alias), | ||||
# XXX See note above | ||||
#("alias_head.with_dot unshadowed, autocall=%s" % ac_state, handle_alias), | ||||
("alias_cmd.something aliases must match whole expr", handle_normal), | ||||
]) | ||||
for ns in [ip.user_ns, ip.IP.internal_ns, __builtin__.__dict__ ]: | ||||
ns['alias_cmd'] = 'a user value' | ||||
ns['alias_head'] = 'a user value' | ||||
run_handler_tests([ | ||||
("alias_cmd", handle_normal), | ||||
("alias_head.with_dot", handle_normal)]) | ||||
del ns['alias_cmd'] | ||||
del ns['alias_head'] | ||||
ip.options.autocall = 1 | ||||
# Autocall | ||||
# ======== | ||||
# First, with autocalling fully off | ||||
ip.options.autocall = 0 | ||||
run_handler_tests( [ | ||||
# Since len is callable, these *should* get auto-called | ||||
# XXX Except, at the moment, they're *not*, because the code is wrong | ||||
# XXX So I'm commenting 'em out to keep the tests quiet | ||||
#( '/len autocall_0', handle_auto), | ||||
#( ',len autocall_0 b0', handle_auto), | ||||
#( ';len autocall_0 b0', handle_auto), | ||||
# But these, since fun is not a callable, should *not* get auto-called | ||||
( '/fun autocall_0', handle_normal), | ||||
( ',fun autocall_0 b0', handle_normal), | ||||
( ';fun autocall_0 b0', handle_normal), | ||||
# With no escapes, no autocalling should happen, callable or not | ||||
( 'len autocall_0', handle_normal), | ||||
( 'fun autocall_0', handle_normal), | ||||
]) | ||||
# Now, with autocall in default, 'smart' mode | ||||
ip.options.autocall = 1 | ||||
run_handler_tests( [ | ||||
# Since len is callable, these *do* get auto-called | ||||
( '/len a1', handle_auto), | ||||
( ',len a1 b1', handle_auto), | ||||
( ';len a1 b1', handle_auto), | ||||
# But these, since fun is not a callable, should *not* get auto-called | ||||
( '/fun a1', handle_normal), | ||||
( ',fun a1 b1', handle_normal), | ||||
( ';fun a1 b1', handle_normal), | ||||
# Autocalls without escapes | ||||
( 'len a1', handle_auto), | ||||
( 'fun a1', handle_normal), # Not callable -> no add | ||||
# Autocalls only happen on things which look like funcs, even if | ||||
# explicitly requested. Which, in this case means they look like a | ||||
# sequence of identifiers and . attribute references. So the second | ||||
# test should pass, but it's not at the moment (meaning, IPython is | ||||
# attempting to run an autocall). Though it does blow up in ipython | ||||
# later (because of how lines are split, I think). | ||||
( '"abc".join range(4)', handle_normal), | ||||
# XXX ( '/"abc".join range(4)', handle_normal), | ||||
]) | ||||
# No tests for autocall = 2, since the extra magic there happens inside the | ||||
# handle_auto function, which our test doesn't examine. | ||||
# Note that we leave autocall in default, 1, 'smart' mode | ||||
# Autocall / Binary operators | ||||
# ========================== | ||||
# Even with autocall on, 'len in thing' won't transform. | ||||
# But ';len in thing' will | ||||
# Note, the tests below don't check for multi-char ops. It could. | ||||
# XXX % is a binary op and should be in the list, too, but fails | ||||
bin_ops = list(r'<>,&^|*/+-') + 'is not in and or'.split() | ||||
bin_tests = [] | ||||
for b in bin_ops: | ||||
bin_tests.append(('len %s binop_autocall' % b, handle_normal)) | ||||
bin_tests.append((';len %s binop_autocall' % b, handle_auto)) | ||||
bin_tests.append((',len %s binop_autocall' % b, handle_auto)) | ||||
bin_tests.append(('/len %s binop_autocall' % b, handle_auto)) | ||||
# Who loves auto-generating tests? | ||||
run_handler_tests(bin_tests) | ||||
# Possibly add tests for namespace shadowing (really ofind's business?). | ||||
# | ||||
# user > ipython internal > python builtin > alias > magic | ||||
# ============ | ||||
# Test Summary | ||||
# ============ | ||||
num_f = len(failures) | ||||
if verbose: | ||||
print "%s tests run, %s failure%s" % (num_tests, | ||||
num_f, | ||||
num_f != 1 and "s" or "") | ||||
for f in failures: | ||||
print f | ||||