Show More
test_magic.py
723 lines
| 20.3 KiB
| text/x-python
|
PythonLexer
MinRK
|
r6211 | # -*- coding: utf-8 -*- | |
Fernando Perez
|
r1848 | """Tests for various magic functions. | |
Ville M. Vainio
|
r1735 | ||
Fernando Perez
|
r1848 | Needs to be run by nose (to make ipython session available). | |
Ville M. Vainio
|
r1735 | """ | |
Fernando Perez
|
r2414 | from __future__ import absolute_import | |
Fernando Perez
|
r1762 | ||
Fernando Perez
|
r2414 | #----------------------------------------------------------------------------- | |
# Imports | |||
#----------------------------------------------------------------------------- | |||
MinRK
|
r6211 | import io | |
Fernando Perez
|
r1848 | import os | |
MinRK
|
r6108 | import sys | |
from StringIO import StringIO | |||
Fernando Perez
|
r6974 | from unittest import TestCase | |
Fernando Perez
|
r1848 | ||
Thomas Kluyver
|
r7019 | try: | |
from importlib import invalidate_caches # Required from Python 3.3 | |||
except ImportError: | |||
def invalidate_caches(): | |||
pass | |||
Fernando Perez
|
r1848 | import nose.tools as nt | |
Fernando Perez
|
r6942 | from IPython.core import magic | |
Fernando Perez
|
r6974 | from IPython.core.magic import (Magics, magics_class, line_magic, | |
cell_magic, line_cell_magic, | |||
register_line_magic, register_cell_magic, | |||
register_line_cell_magic) | |||
MinRK
|
r7407 | from IPython.core.magics import execution, script | |
MinRK
|
r6211 | from IPython.nbformat.v3.tests.nbexamples import nb0 | |
from IPython.nbformat import current | |||
Fernando Perez
|
r1762 | from IPython.testing import decorators as dec | |
Fernando Perez
|
r1955 | from IPython.testing import tools as tt | |
Thomas Kluyver
|
r4895 | from IPython.utils import py3compat | |
Thomas Kluyver
|
r6183 | from IPython.utils.tempdir import TemporaryDirectory | |
MinRK
|
r7407 | from IPython.utils.process import find_cmd | |
Fernando Perez
|
r1955 | ||
Fernando Perez
|
r1848 | #----------------------------------------------------------------------------- | |
# Test functions begin | |||
Fernando Perez
|
r2414 | #----------------------------------------------------------------------------- | |
Fernando Perez
|
r5436 | ||
Fernando Perez
|
r6973 | @magic.magics_class | |
Fernando Perez
|
r6943 | class DummyMagics(magic.Magics): pass | |
MinRK
|
r6211 | ||
Ville M. Vainio
|
r1735 | def test_rehashx(): | |
# clear up everything | |||
Brian Granger
|
r2245 | _ip = get_ipython() | |
_ip.alias_manager.alias_table.clear() | |||
Ville M. Vainio
|
r1735 | del _ip.db['syscmdlist'] | |
_ip.magic('rehashx') | |||
# Practically ALL ipython development systems will have more than 10 aliases | |||
Brian Granger
|
r2245 | yield (nt.assert_true, len(_ip.alias_manager.alias_table) > 10) | |
Thomas Kluyver
|
r3114 | for key, val in _ip.alias_manager.alias_table.iteritems(): | |
Ville M. Vainio
|
r1735 | # we must strip dots from alias names | |
Fernando Perez
|
r2092 | nt.assert_true('.' not in key) | |
Ville M. Vainio
|
r1735 | ||
# rehashx must fill up syscmdlist | |||
scoms = _ip.db['syscmdlist'] | |||
Fernando Perez
|
r2092 | yield (nt.assert_true, len(scoms) > 10) | |
Fernando Perez
|
r1762 | ||
Fernando Perez
|
r2450 | def test_magic_parse_options(): | |
"""Test that we don't mangle paths when parsing magic options.""" | |||
ip = get_ipython() | |||
path = 'c:\\x' | |||
Fernando Perez
|
r6943 | m = DummyMagics(ip) | |
Fernando Perez
|
r6942 | opts = m.parse_options('-f %s' % path,'f:')[0] | |
Fernando Perez
|
r2450 | # argv splitting is os-dependent | |
if os.name == 'posix': | |||
expected = 'c:x' | |||
else: | |||
expected = path | |||
nt.assert_equals(opts['f'], expected) | |||
MinRK
|
r7041 | def test_magic_parse_long_options(): | |
"""Magic.parse_options can handle --foo=bar long options""" | |||
ip = get_ipython() | |||
m = DummyMagics(ip) | |||
opts, _ = m.parse_options('--foo --bar=bubble', 'a', 'foo', 'bar=') | |||
nt.assert_true('foo' in opts) | |||
nt.assert_true('bar' in opts) | |||
nt.assert_true(opts['bar'], "bubble") | |||
MinRK
|
r5147 | ||
@dec.skip_without('sqlite3') | |||
Fernando Perez
|
r1762 | def doctest_hist_f(): | |
"""Test %hist -f with temporary filename. | |||
In [9]: import tempfile | |||
In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-') | |||
Thomas Kluyver
|
r3396 | In [11]: %hist -nl -f $tfile 3 | |
Fernando Perez
|
r2450 | ||
In [13]: import os; os.unlink(tfile) | |||
Fernando Perez
|
r1762 | """ | |
MinRK
|
r5147 | @dec.skip_without('sqlite3') | |
Fernando Perez
|
r1762 | def doctest_hist_r(): | |
"""Test %hist -r | |||
Fernando Perez
|
r2441 | XXX - This test is not recording the output correctly. For some reason, in | |
testing mode the raw history isn't getting populated. No idea why. | |||
Disabling the output checking for now, though at least we do run it. | |||
Fernando Perez
|
r1762 | ||
Fernando Perez
|
r2441 | In [1]: 'hist' in _ip.lsmagic() | |
Out[1]: True | |||
Fernando Perez
|
r2092 | ||
Fernando Perez
|
r2441 | In [2]: x=1 | |
Fernando Perez
|
r1762 | ||
Thomas Kluyver
|
r3396 | In [3]: %hist -rl 2 | |
Fernando Perez
|
r2441 | x=1 # random | |
%hist -r 2 | |||
Fernando Perez
|
r1762 | """ | |
MinRK
|
r5147 | ||
@dec.skip_without('sqlite3') | |||
Fernando Perez
|
r2441 | def doctest_hist_op(): | |
"""Test %hist -op | |||
Thomas Kluyver
|
r4895 | In [1]: class b(float): | |
...: pass | |||
Fernando Perez
|
r2441 | ...: | |
Thomas Kluyver
|
r4895 | In [2]: class s(object): | |
...: def __str__(self): | |||
...: return 's' | |||
Fernando Perez
|
r2441 | ...: | |
In [3]: | |||
In [4]: class r(b): | |||
Thomas Kluyver
|
r4895 | ...: def __repr__(self): | |
...: return 'r' | |||
Fernando Perez
|
r2441 | ...: | |
In [5]: class sr(s,r): pass | |||
...: | |||
In [6]: | |||
In [7]: bb=b() | |||
In [8]: ss=s() | |||
In [9]: rr=r() | |||
In [10]: ssrr=sr() | |||
Thomas Kluyver
|
r4895 | In [11]: 4.5 | |
Out[11]: 4.5 | |||
Fernando Perez
|
r2441 | ||
Thomas Kluyver
|
r4895 | In [12]: str(ss) | |
Out[12]: 's' | |||
Fernando Perez
|
r2441 | ||
In [13]: | |||
In [14]: %hist -op | |||
>>> class b: | |||
... pass | |||
... | |||
>>> class s(b): | |||
... def __str__(self): | |||
... return 's' | |||
... | |||
>>> | |||
>>> class r(b): | |||
... def __repr__(self): | |||
... return 'r' | |||
... | |||
>>> class sr(s,r): pass | |||
>>> | |||
>>> bb=b() | |||
>>> ss=s() | |||
>>> rr=r() | |||
>>> ssrr=sr() | |||
Thomas Kluyver
|
r4895 | >>> 4.5 | |
4.5 | |||
>>> str(ss) | |||
's' | |||
Fernando Perez
|
r2441 | >>> | |
""" | |||
MinRK
|
r5147 | ||
@dec.skip_without('sqlite3') | |||
Thomas Kluyver
|
r3385 | def test_macro(): | |
ip = get_ipython() | |||
ip.history_manager.reset() # Clear any existing history. | |||
cmds = ["a=1", "def b():\n return a**2", "print(a,b())"] | |||
Thomas Kluyver
|
r3396 | for i, cmd in enumerate(cmds, start=1): | |
ip.history_manager.store_inputs(i, cmd) | |||
Thomas Kluyver
|
r3385 | ip.magic("macro test 1-3") | |
nt.assert_equal(ip.user_ns["test"].value, "\n".join(cmds)+"\n") | |||
Thomas Kluyver
|
r3386 | # List macros. | |
assert "test" in ip.magic("macro") | |||
Fernando Perez
|
r2392 | ||
MinRK
|
r5147 | ||
@dec.skip_without('sqlite3') | |||
Thomas Kluyver
|
r3414 | def test_macro_run(): | |
"""Test that we can run a multi-line macro successfully.""" | |||
ip = get_ipython() | |||
ip.history_manager.reset() | |||
Thomas Kluyver
|
r4895 | cmds = ["a=10", "a+=1", py3compat.doctest_refactor_print("print a"), | |
"%macro test 2-3"] | |||
Thomas Kluyver
|
r3414 | for cmd in cmds: | |
Thomas Kluyver
|
r4995 | ip.run_cell(cmd, store_history=True) | |
Thomas Kluyver
|
r4895 | nt.assert_equal(ip.user_ns["test"].value, | |
py3compat.doctest_refactor_print("a+=1\nprint a\n")) | |||
Thomas Kluyver
|
r4903 | with tt.AssertPrints("12"): | |
Thomas Kluyver
|
r3414 | ip.run_cell("test") | |
Thomas Kluyver
|
r4903 | with tt.AssertPrints("13"): | |
Thomas Kluyver
|
r3414 | ip.run_cell("test") | |
Fernando Perez
|
r2092 | ||
Paul Ivanov
|
r5939 | @dec.skipif_not_numpy | |
Paul Ivanov
|
r5965 | def test_numpy_reset_array_undec(): | |
"Test '%reset array' functionality" | |||
Fernando Perez
|
r1848 | _ip.ex('import numpy as np') | |
_ip.ex('a = np.empty(2)') | |||
Fernando Perez
|
r2092 | yield (nt.assert_true, 'a' in _ip.user_ns) | |
Paul Ivanov
|
r5965 | _ip.magic('reset -f array') | |
Fernando Perez
|
r2092 | yield (nt.assert_false, 'a' in _ip.user_ns) | |
Paul Ivanov
|
r5939 | ||
Paul Ivanov
|
r5976 | def test_reset_out(): | |
"Test '%reset out' magic" | |||
Paul Ivanov
|
r5939 | _ip.run_cell("parrot = 'dead'", store_history=True) | |
Paul Ivanov
|
r5965 | # test '%reset -f out', make an Out prompt | |
Paul Ivanov
|
r5939 | _ip.run_cell("parrot", store_history=True) | |
nt.assert_true('dead' in [_ip.user_ns[x] for x in '_','__','___']) | |||
Paul Ivanov
|
r5965 | _ip.magic('reset -f out') | |
Paul Ivanov
|
r5939 | nt.assert_false('dead' in [_ip.user_ns[x] for x in '_','__','___']) | |
Paul Ivanov
|
r5940 | nt.assert_true(len(_ip.user_ns['Out']) == 0) | |
Paul Ivanov
|
r5939 | ||
Paul Ivanov
|
r5976 | def test_reset_in(): | |
"Test '%reset in' magic" | |||
Paul Ivanov
|
r5965 | # test '%reset -f in' | |
Paul Ivanov
|
r5939 | _ip.run_cell("parrot", store_history=True) | |
nt.assert_true('parrot' in [_ip.user_ns[x] for x in '_i','_ii','_iii']) | |||
Paul Ivanov
|
r5965 | _ip.magic('%reset -f in') | |
Paul Ivanov
|
r5939 | nt.assert_false('parrot' in [_ip.user_ns[x] for x in '_i','_ii','_iii']) | |
Paul Ivanov
|
r5957 | nt.assert_true(len(set(_ip.user_ns['In'])) == 1) | |
Paul Ivanov
|
r5939 | ||
Paul Ivanov
|
r5976 | def test_reset_dhist(): | |
"Test '%reset dhist' magic" | |||
Paul Ivanov
|
r5939 | _ip.run_cell("tmp = [d for d in _dh]") # copy before clearing | |
Paul Ivanov
|
r5976 | _ip.magic('cd ' + os.path.dirname(nt.__file__)) | |
Paul Ivanov
|
r5939 | _ip.magic('cd -') | |
nt.assert_true(len(_ip.user_ns['_dh']) > 0) | |||
Paul Ivanov
|
r5965 | _ip.magic('reset -f dhist') | |
Paul Ivanov
|
r5939 | nt.assert_true(len(_ip.user_ns['_dh']) == 0) | |
_ip.run_cell("_dh = [d for d in tmp]") #restore | |||
Fernando Perez
|
r1762 | ||
Paul Ivanov
|
r5976 | def test_reset_in_length(): | |
"Test that '%reset in' preserves In[] length" | |||
Paul Ivanov
|
r5957 | _ip.run_cell("print 'foo'") | |
Paul Ivanov
|
r5965 | _ip.run_cell("reset -f in") | |
Paul Ivanov
|
r5957 | nt.assert_true(len(_ip.user_ns['In']) == _ip.displayhook.prompt_count+1) | |
Fernando Perez
|
r1762 | ||
Fernando Perez
|
r2411 | def test_time(): | |
_ip.magic('time None') | |||
MinRK
|
r6108 | def test_tb_syntaxerror(): | |
"""test %tb after a SyntaxError""" | |||
ip = get_ipython() | |||
ip.run_cell("for") | |||
# trap and validate stdout | |||
save_stdout = sys.stdout | |||
try: | |||
sys.stdout = StringIO() | |||
ip.run_cell("%tb") | |||
out = sys.stdout.getvalue() | |||
finally: | |||
sys.stdout = save_stdout | |||
# trim output, and only check the last line | |||
last_line = out.rstrip().splitlines()[-1].strip() | |||
nt.assert_equals(last_line, "SyntaxError: invalid syntax") | |||
Fernando Perez
|
r2411 | ||
Thomas Kluyver
|
r4895 | @py3compat.doctest_refactor_print | |
Fernando Perez
|
r2411 | def doctest_time(): | |
""" | |||
In [10]: %time None | |||
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s | |||
Wall time: 0.00 s | |||
Thomas Kluyver
|
r3478 | ||
In [11]: def f(kmjy): | |||
....: %time print 2*kmjy | |||
In [12]: f(3) | |||
6 | |||
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s | |||
Wall time: 0.00 s | |||
Fernando Perez
|
r2411 | """ | |
Fernando Perez
|
r2426 | ||
Fernando Perez
|
r2650 | ||
Fernando Perez
|
r2426 | def test_doctest_mode(): | |
"Toggle doctest_mode twice, it should be a no-op and run without error" | |||
_ip.magic('doctest_mode') | |||
_ip.magic('doctest_mode') | |||
Fernando Perez
|
r2650 | ||
def test_parse_options(): | |||
"""Tests for basic options parsing in magics.""" | |||
# These are only the most minimal of tests, more should be added later. At | |||
# the very least we check that basic text/unicode calls work OK. | |||
Fernando Perez
|
r6943 | m = DummyMagics(_ip) | |
Fernando Perez
|
r6942 | nt.assert_equal(m.parse_options('foo', '')[1], 'foo') | |
nt.assert_equal(m.parse_options(u'foo', '')[1], u'foo') | |||
Fernando Perez
|
r2650 | ||
Fernando Perez
|
r2426 | ||
Fernando Perez
|
r2650 | def test_dirops(): | |
"""Test various directory handling operations.""" | |||
Min RK
|
r4105 | # curpath = lambda :os.path.splitdrive(os.getcwdu())[1].replace('\\','/') | |
curpath = os.getcwdu | |||
Thomas Kluyver
|
r3451 | startdir = os.getcwdu() | |
Gabriel
|
r5663 | ipdir = os.path.realpath(_ip.ipython_dir) | |
Fernando Perez
|
r2650 | try: | |
_ip.magic('cd "%s"' % ipdir) | |||
nt.assert_equal(curpath(), ipdir) | |||
_ip.magic('cd -') | |||
nt.assert_equal(curpath(), startdir) | |||
_ip.magic('pushd "%s"' % ipdir) | |||
nt.assert_equal(curpath(), ipdir) | |||
_ip.magic('popd') | |||
nt.assert_equal(curpath(), startdir) | |||
finally: | |||
os.chdir(startdir) | |||
Fernando Perez
|
r2655 | ||
Fernando Perez
|
r3146 | def test_xmode(): | |
# Calling xmode three times should be a no-op | |||
xmode = _ip.InteractiveTB.mode | |||
for i in range(3): | |||
_ip.magic("xmode") | |||
nt.assert_equal(_ip.InteractiveTB.mode, xmode) | |||
Thomas Kluyver
|
r3522 | ||
def test_reset_hard(): | |||
monitor = [] | |||
class A(object): | |||
def __del__(self): | |||
monitor.append(1) | |||
def __repr__(self): | |||
return "<A instance>" | |||
_ip.user_ns["a"] = A() | |||
_ip.run_cell("a") | |||
nt.assert_equal(monitor, []) | |||
Fernando Perez
|
r6916 | _ip.magic("reset -f") | |
Thomas Kluyver
|
r3522 | nt.assert_equal(monitor, [1]) | |
Thomas Kluyver
|
r3824 | ||
class TestXdel(tt.TempFileMixin): | |||
def test_xdel(self): | |||
"""Test that references from %run are cleared by xdel.""" | |||
src = ("class A(object):\n" | |||
" monitor = []\n" | |||
" def __del__(self):\n" | |||
" self.monitor.append(1)\n" | |||
"a = A()\n") | |||
self.mktmp(src) | |||
Thomas Kluyver
|
r3832 | # %run creates some hidden references... | |
Thomas Kluyver
|
r3824 | _ip.magic("run %s" % self.fname) | |
Thomas Kluyver
|
r3832 | # ... as does the displayhook. | |
Thomas Kluyver
|
r3824 | _ip.run_cell("a") | |
Thomas Kluyver
|
r3844 | ||
Thomas Kluyver
|
r3824 | monitor = _ip.user_ns["A"].monitor | |
nt.assert_equal(monitor, []) | |||
Thomas Kluyver
|
r3832 | ||
Thomas Kluyver
|
r3844 | _ip.magic("xdel a") | |
Thomas Kluyver
|
r3832 | ||
# Check that a's __del__ method has been called. | |||
Thomas Kluyver
|
r3824 | nt.assert_equal(monitor, [1]) | |
MinRK
|
r3332 | ||
def doctest_who(): | |||
"""doctest for %who | |||
In [1]: %reset -f | |||
In [2]: alpha = 123 | |||
In [3]: beta = 'beta' | |||
In [4]: %who int | |||
alpha | |||
In [5]: %who str | |||
beta | |||
In [6]: %whos | |||
Variable Type Data/Info | |||
---------------------------- | |||
alpha int 123 | |||
beta str beta | |||
In [7]: %who_ls | |||
Out[7]: ['alpha', 'beta'] | |||
MinRK
|
r3350 | """ | |
Thomas Kluyver
|
r6779 | def test_whos(): | |
"""Check that whos is protected against objects where repr() fails.""" | |||
class A(object): | |||
def __repr__(self): | |||
raise Exception() | |||
_ip.user_ns['a'] = A() | |||
_ip.magic("whos") | |||
Thomas Kluyver
|
r4895 | @py3compat.u_format | |
MinRK
|
r3350 | def doctest_precision(): | |
"""doctest for %precision | |||
Fernando Perez
|
r6916 | In [1]: f = get_ipython().display_formatter.formatters['text/plain'] | |
MinRK
|
r3350 | ||
In [2]: %precision 5 | |||
Thomas Kluyver
|
r4895 | Out[2]: {u}'%.5f' | |
MinRK
|
r3350 | ||
In [3]: f.float_format | |||
Thomas Kluyver
|
r4895 | Out[3]: {u}'%.5f' | |
MinRK
|
r3350 | ||
In [4]: %precision %e | |||
Thomas Kluyver
|
r4895 | Out[4]: {u}'%e' | |
MinRK
|
r3350 | ||
In [5]: f(3.1415927) | |||
Thomas Kluyver
|
r4895 | Out[5]: {u}'3.141593e+00' | |
MinRK
|
r3350 | """ | |
Thomas Kluyver
|
r5549 | def test_psearch(): | |
with tt.AssertPrints("dict.fromkeys"): | |||
_ip.run_cell("dict.fr*?") | |||
MinRK
|
r5672 | def test_timeit_shlex(): | |
"""test shlex issues with timeit (#1109)""" | |||
_ip.ex("def f(*a,**kw): pass") | |||
_ip.magic('timeit -n1 "this is a bug".count(" ")') | |||
_ip.magic('timeit -r1 -n1 f(" ", 1)') | |||
_ip.magic('timeit -r1 -n1 f(" ", 1, " ", 2, " ")') | |||
_ip.magic('timeit -r1 -n1 ("a " + "b")') | |||
_ip.magic('timeit -r1 -n1 f("a " + "b")') | |||
_ip.magic('timeit -r1 -n1 f("a " + "b ")') | |||
Paul Ivanov
|
r5901 | ||
def test_timeit_arguments(): | |||
"Test valid timeit arguments, should not cause SyntaxError (GH #1269)" | |||
_ip.magic("timeit ('#')") | |||
Paul Ivanov
|
r5932 | ||
Fernando Perez
|
r6942 | ||
Fernando Perez
|
r7493 | def test_timeit_special_syntax(): | |
"Test %%timeit with IPython special syntax" | |||
Fernando Perez
|
r7492 | from IPython.core.magic import register_line_magic | |
@register_line_magic | |||
def lmagic(line): | |||
ip = get_ipython() | |||
ip.user_ns['lmagic_out'] = line | |||
Fernando Perez
|
r7493 | # line mode test | |
_ip.run_line_magic('timeit', '-n1 -r1 %lmagic my line') | |||
Fernando Perez
|
r7492 | nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line') | |
Fernando Perez
|
r7493 | # cell mode test | |
_ip.run_cell_magic('timeit', '-n1 -r1', '%lmagic my line2') | |||
nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line2') | |||
Fernando Perez
|
r7492 | ||
Fernando Perez
|
r6970 | @dec.skipif(execution.profile is None) | |
Paul Ivanov
|
r5932 | def test_prun_quotes(): | |
"Test that prun does not clobber string escapes (GH #1302)" | |||
Jörgen Stenarson
|
r7458 | _ip.magic(r"prun -q x = '\t'") | |
Paul Ivanov
|
r5932 | nt.assert_equal(_ip.user_ns['x'], '\t') | |
Thomas Kluyver
|
r6183 | ||
def test_extension(): | |||
tmpdir = TemporaryDirectory() | |||
orig_ipython_dir = _ip.ipython_dir | |||
try: | |||
_ip.ipython_dir = tmpdir.name | |||
nt.assert_raises(ImportError, _ip.magic, "load_ext daft_extension") | |||
url = os.path.join(os.path.dirname(__file__), "daft_extension.py") | |||
_ip.magic("install_ext %s" % url) | |||
_ip.user_ns.pop('arq', None) | |||
Thomas Kluyver
|
r7019 | invalidate_caches() # Clear import caches | |
Thomas Kluyver
|
r6183 | _ip.magic("load_ext daft_extension") | |
tt.assert_equal(_ip.user_ns['arq'], 185) | |||
_ip.magic("unload_ext daft_extension") | |||
assert 'arq' not in _ip.user_ns | |||
finally: | |||
_ip.ipython_dir = orig_ipython_dir | |||
MinRK
|
r6211 | def test_notebook_export_json(): | |
with TemporaryDirectory() as td: | |||
outfile = os.path.join(td, "nb.ipynb") | |||
MinRK
|
r6475 | _ip.ex(py3compat.u_format(u"u = {u}'héllo'")) | |
MinRK
|
r6211 | _ip.magic("notebook -e %s" % outfile) | |
def test_notebook_export_py(): | |||
with TemporaryDirectory() as td: | |||
outfile = os.path.join(td, "nb.py") | |||
MinRK
|
r6475 | _ip.ex(py3compat.u_format(u"u = {u}'héllo'")) | |
MinRK
|
r6211 | _ip.magic("notebook -e %s" % outfile) | |
def test_notebook_reformat_py(): | |||
with TemporaryDirectory() as td: | |||
infile = os.path.join(td, "nb.ipynb") | |||
Thomas Kluyver
|
r6488 | with io.open(infile, 'w', encoding='utf-8') as f: | |
MinRK
|
r6211 | current.write(nb0, f, 'json') | |
MinRK
|
r6475 | _ip.ex(py3compat.u_format(u"u = {u}'héllo'")) | |
MinRK
|
r6211 | _ip.magic("notebook -f py %s" % infile) | |
def test_notebook_reformat_json(): | |||
with TemporaryDirectory() as td: | |||
infile = os.path.join(td, "nb.py") | |||
Thomas Kluyver
|
r6488 | with io.open(infile, 'w', encoding='utf-8') as f: | |
MinRK
|
r6211 | current.write(nb0, f, 'py') | |
MinRK
|
r6475 | _ip.ex(py3compat.u_format(u"u = {u}'héllo'")) | |
MinRK
|
r6211 | _ip.magic("notebook -f ipynb %s" % infile) | |
_ip.magic("notebook -f json %s" % infile) | |||
Thomas Kluyver
|
r6489 | def test_env(): | |
env = _ip.magic("env") | |||
assert isinstance(env, dict), type(env) | |||
Fernando Perez
|
r6975 | ||
class CellMagicTestCase(TestCase): | |||
def check_ident(self, magic): | |||
Fernando Perez
|
r6976 | # Manually called, we get the result | |
Fernando Perez
|
r7003 | out = _ip.run_cell_magic(magic, 'a', 'b') | |
Fernando Perez
|
r6975 | nt.assert_equals(out, ('a','b')) | |
Fernando Perez
|
r6976 | # Via run_cell, it goes into the user's namespace via displayhook | |
_ip.run_cell('%%' + magic +' c\nd') | |||
nt.assert_equals(_ip.user_ns['_'], ('c','d')) | |||
Fernando Perez
|
r6975 | ||
def test_cell_magic_func_deco(self): | |||
"Cell magic using simple decorator" | |||
@register_cell_magic | |||
def cellm(line, cell): | |||
return line, cell | |||
self.check_ident('cellm') | |||
def test_cell_magic_reg(self): | |||
"Cell magic manually registered" | |||
def cellm(line, cell): | |||
return line, cell | |||
_ip.register_magic_function(cellm, 'cell', 'cellm2') | |||
self.check_ident('cellm2') | |||
def test_cell_magic_class(self): | |||
"Cell magics declared via a class" | |||
@magics_class | |||
class MyMagics(Magics): | |||
@cell_magic | |||
def cellm3(self, line, cell): | |||
return line, cell | |||
Fernando Perez
|
r6976 | _ip.register_magics(MyMagics) | |
self.check_ident('cellm3') | |||
def test_cell_magic_class2(self): | |||
"Cell magics declared via a class, #2" | |||
@magics_class | |||
class MyMagics2(Magics): | |||
Fernando Perez
|
r6975 | @cell_magic('cellm4') | |
def cellm33(self, line, cell): | |||
return line, cell | |||
Fernando Perez
|
r6976 | ||
_ip.register_magics(MyMagics2) | |||
Fernando Perez
|
r6975 | self.check_ident('cellm4') | |
# Check that nothing is registered as 'cellm33' | |||
c33 = _ip.find_cell_magic('cellm33') | |||
nt.assert_equals(c33, None) | |||
MinRK
|
r7407 | ||
def test_file(): | |||
"""Basic %%file""" | |||
ip = get_ipython() | |||
with TemporaryDirectory() as td: | |||
fname = os.path.join(td, 'file1') | |||
ip.run_cell_magic("file", fname, u'\n'.join([ | |||
'line1', | |||
'line2', | |||
])) | |||
with open(fname) as f: | |||
s = f.read() | |||
nt.assert_in('line1\n', s) | |||
nt.assert_in('line2', s) | |||
def test_file_unicode(): | |||
"""%%file with unicode cell""" | |||
ip = get_ipython() | |||
with TemporaryDirectory() as td: | |||
fname = os.path.join(td, 'file1') | |||
ip.run_cell_magic("file", fname, u'\n'.join([ | |||
u'liné1', | |||
u'liné2', | |||
])) | |||
with io.open(fname, encoding='utf-8') as f: | |||
s = f.read() | |||
nt.assert_in(u'liné1\n', s) | |||
nt.assert_in(u'liné2', s) | |||
def test_file_amend(): | |||
"""%%file -a amends files""" | |||
ip = get_ipython() | |||
with TemporaryDirectory() as td: | |||
fname = os.path.join(td, 'file2') | |||
ip.run_cell_magic("file", fname, u'\n'.join([ | |||
'line1', | |||
'line2', | |||
])) | |||
ip.run_cell_magic("file", "-a %s" % fname, u'\n'.join([ | |||
'line3', | |||
'line4', | |||
])) | |||
with open(fname) as f: | |||
s = f.read() | |||
nt.assert_in('line1\n', s) | |||
nt.assert_in('line3\n', s) | |||
Fernando Perez
|
r6997 | ||
MinRK
|
r7407 | def test_script_config(): | |
ip = get_ipython() | |||
ip.config.ScriptMagics.script_magics = ['whoda'] | |||
sm = script.ScriptMagics(shell=ip) | |||
nt.assert_in('whoda', sm.magics['cell']) | |||
@dec.skip_win32 | |||
def test_script_out(): | |||
ip = get_ipython() | |||
ip.run_cell_magic("script", "--out output sh", "echo 'hi'") | |||
nt.assert_equals(ip.user_ns['output'], 'hi\n') | |||
@dec.skip_win32 | |||
def test_script_err(): | |||
ip = get_ipython() | |||
ip.run_cell_magic("script", "--err error sh", "echo 'hello' >&2") | |||
nt.assert_equals(ip.user_ns['error'], 'hello\n') | |||
@dec.skip_win32 | |||
def test_script_out_err(): | |||
ip = get_ipython() | |||
ip.run_cell_magic("script", "--out output --err error sh", "echo 'hi'\necho 'hello' >&2") | |||
nt.assert_equals(ip.user_ns['output'], 'hi\n') | |||
nt.assert_equals(ip.user_ns['error'], 'hello\n') | |||
@dec.skip_win32 | |||
def test_script_bg_out(): | |||
ip = get_ipython() | |||
ip.run_cell_magic("script", "--bg --out output sh", "echo 'hi'") | |||
MinRK
|
r7440 | nt.assert_equals(ip.user_ns['output'].read(), b'hi\n') | |
MinRK
|
r7407 | ||
@dec.skip_win32 | |||
def test_script_bg_err(): | |||
ip = get_ipython() | |||
ip.run_cell_magic("script", "--bg --err error sh", "echo 'hello' >&2") | |||
MinRK
|
r7440 | nt.assert_equals(ip.user_ns['error'].read(), b'hello\n') | |
MinRK
|
r7407 | ||
@dec.skip_win32 | |||
def test_script_bg_out_err(): | |||
ip = get_ipython() | |||
ip.run_cell_magic("script", "--bg --out output --err error sh", "echo 'hi'\necho 'hello' >&2") | |||
MinRK
|
r7440 | nt.assert_equals(ip.user_ns['output'].read(), b'hi\n') | |
nt.assert_equals(ip.user_ns['error'].read(), b'hello\n') | |||
MinRK
|
r7407 | ||
def test_script_defaults(): | |||
ip = get_ipython() | |||
for cmd in ['sh', 'bash', 'perl', 'ruby']: | |||
try: | |||
find_cmd(cmd) | |||
except Exception: | |||
pass | |||
else: | |||
nt.assert_in(cmd, ip.magics_manager.magics['cell']) | |||
MinRK
|
r7436 | ||
@magics_class | |||
class FooFoo(Magics): | |||
"""class with both %foo and %%foo magics""" | |||
@line_magic('foo') | |||
def line_foo(self, line): | |||
"I am line foo" | |||
pass | |||
@cell_magic("foo") | |||
def cell_foo(self, line, cell): | |||
"I am cell foo, not line foo" | |||
pass | |||
def test_line_cell_info(): | |||
"""%%foo and %foo magics are distinguishable to inspect""" | |||
ip = get_ipython() | |||
ip.magics_manager.register(FooFoo) | |||
oinfo = ip.object_inspect('foo') | |||
nt.assert_true(oinfo['found']) | |||
nt.assert_true(oinfo['ismagic']) | |||
oinfo = ip.object_inspect('%%foo') | |||
nt.assert_true(oinfo['found']) | |||
nt.assert_true(oinfo['ismagic']) | |||
nt.assert_equals(oinfo['docstring'], FooFoo.cell_foo.__doc__) | |||
oinfo = ip.object_inspect('%foo') | |||
nt.assert_true(oinfo['found']) | |||
nt.assert_true(oinfo['ismagic']) | |||
nt.assert_equals(oinfo['docstring'], FooFoo.line_foo.__doc__) | |||
MinRK
|
r7583 | ||
def test_multiple_magics(): | |||
ip = get_ipython() | |||
foo1 = FooFoo(ip) | |||
foo2 = FooFoo(ip) | |||
mm = ip.magics_manager | |||
mm.register(foo1) | |||
nt.assert_true(mm.magics['line']['foo'].im_self is foo1) | |||
mm.register(foo2) | |||
nt.assert_true(mm.magics['line']['foo'].im_self is foo2) | |||