##// END OF EJS Templates
nose2pytest migration batch 1...
Tomasz Kłoczko -
Show More
@@ -1,65 +1,65
1 1 from IPython.utils.capture import capture_output
2 2
3 import nose.tools as nt
3 import pytest
4 4
5 5 def test_alias_lifecycle():
6 6 name = 'test_alias1'
7 7 cmd = 'echo "Hello"'
8 8 am = _ip.alias_manager
9 9 am.clear_aliases()
10 10 am.define_alias(name, cmd)
11 11 assert am.is_alias(name)
12 nt.assert_equal(am.retrieve_alias(name), cmd)
13 nt.assert_in((name, cmd), am.aliases)
12 assert am.retrieve_alias(name) == cmd
13 assert (name, cmd) in am.aliases
14 14
15 15 # Test running the alias
16 16 orig_system = _ip.system
17 17 result = []
18 18 _ip.system = result.append
19 19 try:
20 20 _ip.run_cell('%{}'.format(name))
21 21 result = [c.strip() for c in result]
22 nt.assert_equal(result, [cmd])
22 assert result == [cmd]
23 23 finally:
24 24 _ip.system = orig_system
25 25
26 26 # Test removing the alias
27 27 am.undefine_alias(name)
28 28 assert not am.is_alias(name)
29 with nt.assert_raises(ValueError):
29 with pytest.raises(ValueError):
30 30 am.retrieve_alias(name)
31 nt.assert_not_in((name, cmd), am.aliases)
31 assert (name, cmd) not in am.aliases
32 32
33 33
34 34 def test_alias_args_error():
35 35 """Error expanding with wrong number of arguments"""
36 36 _ip.alias_manager.define_alias('parts', 'echo first %s second %s')
37 37 # capture stderr:
38 38 with capture_output() as cap:
39 39 _ip.run_cell('parts 1')
40 40
41 nt.assert_equal(cap.stderr.split(':')[0], 'UsageError')
41 assert cap.stderr.split(':')[0] == 'UsageError'
42 42
43 43 def test_alias_args_commented():
44 44 """Check that alias correctly ignores 'commented out' args"""
45 45 _ip.magic('alias commetarg echo this is %%s a commented out arg')
46 46
47 47 with capture_output() as cap:
48 48 _ip.run_cell('commetarg')
49 49
50 50 # strip() is for pytest compat; testing via iptest patch IPython shell
51 51 # in testin.globalipapp and replace the system call which messed up the
52 52 # \r\n
53 53 assert cap.stdout.strip() == 'this is %s a commented out arg'
54 54
55 55 def test_alias_args_commented_nargs():
56 56 """Check that alias correctly counts args, excluding those commented out"""
57 57 am = _ip.alias_manager
58 58 alias_name = 'comargcount'
59 59 cmd = 'echo this is %%s a commented out arg and this is not %s'
60 60
61 61 am.define_alias(alias_name, cmd)
62 62 assert am.is_alias(alias_name)
63 63
64 64 thealias = am.get_alias(alias_name)
65 nt.assert_equal(thealias.nargs, 1)
65 assert thealias.nargs == 1
@@ -1,73 +1,73
1 1 # coding: utf-8
2 2 """Tests for the compilerop module.
3 3 """
4 4 #-----------------------------------------------------------------------------
5 5 # Copyright (C) 2010-2011 The IPython Development Team.
6 6 #
7 7 # Distributed under the terms of the BSD License.
8 8 #
9 9 # The full license is in the file COPYING.txt, distributed with this software.
10 10 #-----------------------------------------------------------------------------
11 11
12 12 #-----------------------------------------------------------------------------
13 13 # Imports
14 14 #-----------------------------------------------------------------------------
15 15
16 16 # Stdlib imports
17 17 import linecache
18 18 import sys
19 19
20 20 # Third-party imports
21 import nose.tools as nt
21 import pytest
22 22
23 23 # Our own imports
24 24 from IPython.core import compilerop
25 25
26 26 #-----------------------------------------------------------------------------
27 27 # Test functions
28 28 #-----------------------------------------------------------------------------
29 29
30 30 def test_code_name():
31 31 code = 'x=1'
32 32 name = compilerop.code_name(code)
33 nt.assert_true(name.startswith('<ipython-input-0'))
33 assert name.startswith('<ipython-input-0')
34 34
35 35
36 36 def test_code_name2():
37 37 code = 'x=1'
38 38 name = compilerop.code_name(code, 9)
39 nt.assert_true(name.startswith('<ipython-input-9'))
39 assert name.startswith('<ipython-input-9')
40 40
41 41
42 42 def test_cache():
43 43 """Test the compiler correctly compiles and caches inputs
44 44 """
45 45 cp = compilerop.CachingCompiler()
46 46 ncache = len(linecache.cache)
47 47 cp.cache('x=1')
48 nt.assert_true(len(linecache.cache) > ncache)
48 assert len(linecache.cache) > ncache
49 49
50 50 def test_proper_default_encoding():
51 51 # Check we're in a proper Python 2 environment (some imports, such
52 52 # as GTK, can change the default encoding, which can hide bugs.)
53 nt.assert_equal(sys.getdefaultencoding(), "utf-8")
53 assert sys.getdefaultencoding() == "utf-8"
54 54
55 55 def test_cache_unicode():
56 56 cp = compilerop.CachingCompiler()
57 57 ncache = len(linecache.cache)
58 58 cp.cache(u"t = 'žćčšđ'")
59 nt.assert_true(len(linecache.cache) > ncache)
59 assert len(linecache.cache) > ncache
60 60
61 61 def test_compiler_check_cache():
62 62 """Test the compiler properly manages the cache.
63 63 """
64 64 # Rather simple-minded tests that just exercise the API
65 65 cp = compilerop.CachingCompiler()
66 66 cp.cache('x=1', 99)
67 67 # Ensure now that after clearing the cache, our entries survive
68 68 linecache.checkcache()
69 69 for k in linecache.cache:
70 70 if k.startswith('<ipython-input-99'):
71 71 break
72 72 else:
73 73 raise AssertionError('Entry for input-99 missing from linecache')
@@ -1,166 +1,165
1 1 """Tests for the line-based transformers in IPython.core.inputtransformer2
2 2
3 3 Line-based transformers are the simpler ones; token-based transformers are
4 4 more complex. See test_inputtransformer2 for tests for token-based transformers.
5 5 """
6 import nose.tools as nt
6 import pytest
7 7
8 8 from IPython.core import inputtransformer2 as ipt2
9 9
10 10 CELL_MAGIC = ("""\
11 11 %%foo arg
12 12 body 1
13 13 body 2
14 14 """, """\
15 15 get_ipython().run_cell_magic('foo', 'arg', 'body 1\\nbody 2\\n')
16 16 """)
17 17
18 18 def test_cell_magic():
19 19 for sample, expected in [CELL_MAGIC]:
20 nt.assert_equal(ipt2.cell_magic(sample.splitlines(keepends=True)),
20 assert (ipt2.cell_magic(sample.splitlines(keepends=True)) ==
21 21 expected.splitlines(keepends=True))
22 22
23 23 CLASSIC_PROMPT = ("""\
24 24 >>> for a in range(5):
25 25 ... print(a)
26 26 """, """\
27 27 for a in range(5):
28 28 print(a)
29 29 """)
30 30
31 31 CLASSIC_PROMPT_L2 = ("""\
32 32 for a in range(5):
33 33 ... print(a)
34 34 ... print(a ** 2)
35 35 """, """\
36 36 for a in range(5):
37 37 print(a)
38 38 print(a ** 2)
39 39 """)
40 40
41 41 def test_classic_prompt():
42 42 for sample, expected in [CLASSIC_PROMPT, CLASSIC_PROMPT_L2]:
43 nt.assert_equal(ipt2.classic_prompt(sample.splitlines(keepends=True)),
43 assert (ipt2.classic_prompt(sample.splitlines(keepends=True)) ==
44 44 expected.splitlines(keepends=True))
45 45
46 46 IPYTHON_PROMPT = ("""\
47 47 In [1]: for a in range(5):
48 48 ...: print(a)
49 49 """, """\
50 50 for a in range(5):
51 51 print(a)
52 52 """)
53 53
54 54 IPYTHON_PROMPT_L2 = ("""\
55 55 for a in range(5):
56 56 ...: print(a)
57 57 ...: print(a ** 2)
58 58 """, """\
59 59 for a in range(5):
60 60 print(a)
61 61 print(a ** 2)
62 62 """)
63 63
64 64
65 65 IPYTHON_PROMPT_VI_INS = (
66 66 """\
67 67 [ins] In [11]: def a():
68 68 ...: 123
69 69 ...:
70 70 ...: 123
71 71 """,
72 72 """\
73 73 def a():
74 74 123
75 75
76 76 123
77 77 """,
78 78 )
79 79
80 80 IPYTHON_PROMPT_VI_NAV = (
81 81 """\
82 82 [nav] In [11]: def a():
83 83 ...: 123
84 84 ...:
85 85 ...: 123
86 86 """,
87 87 """\
88 88 def a():
89 89 123
90 90
91 91 123
92 92 """,
93 93 )
94 94
95 95
96 96 def test_ipython_prompt():
97 97 for sample, expected in [
98 98 IPYTHON_PROMPT,
99 99 IPYTHON_PROMPT_L2,
100 100 IPYTHON_PROMPT_VI_INS,
101 101 IPYTHON_PROMPT_VI_NAV,
102 102 ]:
103 nt.assert_equal(
104 ipt2.ipython_prompt(sample.splitlines(keepends=True)),
105 expected.splitlines(keepends=True),
106 )
103 assert (
104 ipt2.ipython_prompt(sample.splitlines(keepends=True)) ==
105 expected.splitlines(keepends=True))
107 106
108 107
109 108 INDENT_SPACES = ("""\
110 109 if True:
111 110 a = 3
112 111 """, """\
113 112 if True:
114 113 a = 3
115 114 """)
116 115
117 116 INDENT_TABS = ("""\
118 117 \tif True:
119 118 \t\tb = 4
120 119 """, """\
121 120 if True:
122 121 \tb = 4
123 122 """)
124 123
125 124 def test_leading_indent():
126 125 for sample, expected in [INDENT_SPACES, INDENT_TABS]:
127 nt.assert_equal(ipt2.leading_indent(sample.splitlines(keepends=True)),
126 assert (ipt2.leading_indent(sample.splitlines(keepends=True)) ==
128 127 expected.splitlines(keepends=True))
129 128
130 129 LEADING_EMPTY_LINES = ("""\
131 130 \t
132 131
133 132 if True:
134 133 a = 3
135 134
136 135 b = 4
137 136 """, """\
138 137 if True:
139 138 a = 3
140 139
141 140 b = 4
142 141 """)
143 142
144 143 ONLY_EMPTY_LINES = ("""\
145 144 \t
146 145
147 146 """, """\
148 147 \t
149 148
150 149 """)
151 150
152 151 def test_leading_empty_lines():
153 152 for sample, expected in [LEADING_EMPTY_LINES, ONLY_EMPTY_LINES]:
154 nt.assert_equal(
155 ipt2.leading_empty_lines(sample.splitlines(keepends=True)),
153 assert (
154 ipt2.leading_empty_lines(sample.splitlines(keepends=True)) ==
156 155 expected.splitlines(keepends=True))
157 156
158 157 CRLF_MAGIC = ([
159 158 "%%ls\r\n"
160 159 ], [
161 160 "get_ipython().run_cell_magic('ls', '', '')\n"
162 161 ])
163 162
164 163 def test_crlf_magic():
165 164 for sample, expected in [CRLF_MAGIC]:
166 nt.assert_equal(ipt2.cell_magic(sample), expected)
165 assert ipt2.cell_magic(sample) == expected
@@ -1,238 +1,238
1 1 """Tests for the key interactiveshell module, where the main ipython class is defined.
2 2 """
3 3 #-----------------------------------------------------------------------------
4 4 # Module imports
5 5 #-----------------------------------------------------------------------------
6 6
7 7 # third party
8 import nose.tools as nt
8 import pytest
9 9
10 10 # our own packages
11 11
12 12 #-----------------------------------------------------------------------------
13 13 # Test functions
14 14 #-----------------------------------------------------------------------------
15 15
16 16 def test_reset():
17 17 """reset must clear most namespaces."""
18 18
19 19 # Check that reset runs without error
20 20 ip.reset()
21 21
22 22 # Once we've reset it (to clear of any junk that might have been there from
23 23 # other tests, we can count how many variables are in the user's namespace
24 24 nvars_user_ns = len(ip.user_ns)
25 25 nvars_hidden = len(ip.user_ns_hidden)
26 26
27 27 # Now add a few variables to user_ns, and check that reset clears them
28 28 ip.user_ns['x'] = 1
29 29 ip.user_ns['y'] = 1
30 30 ip.reset()
31 31
32 32 # Finally, check that all namespaces have only as many variables as we
33 33 # expect to find in them:
34 nt.assert_equal(len(ip.user_ns), nvars_user_ns)
35 nt.assert_equal(len(ip.user_ns_hidden), nvars_hidden)
34 assert len(ip.user_ns) == nvars_user_ns
35 assert len(ip.user_ns_hidden) == nvars_hidden
36 36
37 37
38 38 # Tests for reporting of exceptions in various modes, handling of SystemExit,
39 39 # and %tb functionality. This is really a mix of testing ultraTB and interactiveshell.
40 40
41 41 def doctest_tb_plain():
42 42 """
43 43 In [18]: xmode plain
44 44 Exception reporting mode: Plain
45 45
46 46 In [19]: run simpleerr.py
47 47 Traceback (most recent call last):
48 48 ...line 32, in <module>
49 49 bar(mode)
50 50 ...line 16, in bar
51 51 div0()
52 52 ...line 8, in div0
53 53 x/y
54 54 ZeroDivisionError: ...
55 55 """
56 56
57 57
58 58 def doctest_tb_context():
59 59 """
60 60 In [3]: xmode context
61 61 Exception reporting mode: Context
62 62
63 63 In [4]: run simpleerr.py
64 64 ---------------------------------------------------------------------------
65 65 ZeroDivisionError Traceback (most recent call last)
66 66 <BLANKLINE>
67 67 ... in <module>
68 68 29 except IndexError:
69 69 30 mode = 'div'
70 70 ---> 32 bar(mode)
71 71 <BLANKLINE>
72 72 ... in bar(mode)
73 73 14 "bar"
74 74 15 if mode=='div':
75 75 ---> 16 div0()
76 76 17 elif mode=='exit':
77 77 18 try:
78 78 <BLANKLINE>
79 79 ... in div0()
80 80 6 x = 1
81 81 7 y = 0
82 82 ----> 8 x/y
83 83 <BLANKLINE>
84 84 ZeroDivisionError: ...
85 85 """
86 86
87 87
88 88 def doctest_tb_verbose():
89 89 """
90 90 In [5]: xmode verbose
91 91 Exception reporting mode: Verbose
92 92
93 93 In [6]: run simpleerr.py
94 94 ---------------------------------------------------------------------------
95 95 ZeroDivisionError Traceback (most recent call last)
96 96 <BLANKLINE>
97 97 ... in <module>
98 98 29 except IndexError:
99 99 30 mode = 'div'
100 100 ---> 32 bar(mode)
101 101 mode = 'div'
102 102 <BLANKLINE>
103 103 ... in bar(mode='div')
104 104 14 "bar"
105 105 15 if mode=='div':
106 106 ---> 16 div0()
107 107 17 elif mode=='exit':
108 108 18 try:
109 109 <BLANKLINE>
110 110 ... in div0()
111 111 6 x = 1
112 112 7 y = 0
113 113 ----> 8 x/y
114 114 x = 1
115 115 y = 0
116 116 <BLANKLINE>
117 117 ZeroDivisionError: ...
118 118 """
119 119
120 120 # TODO : Marc 2021 – this seem to fail due
121 121 # to upstream changes in CI for whatever reason.
122 122 # Commenting for now, to revive someday (maybe?)
123 123 # nose won't work in 3.10 anyway and we'll have to disable iptest.
124 124 # thus this likely need to bemigrated to pytest.
125 125
126 126
127 127 # def doctest_tb_sysexit():
128 128 # """
129 129 # In [17]: %xmode plain
130 130 # Exception reporting mode: Plain
131 131 #
132 132 # In [18]: %run simpleerr.py exit
133 133 # An exception has occurred, use %tb to see the full traceback.
134 134 # SystemExit: (1, 'Mode = exit')
135 135 #
136 136 # In [19]: %run simpleerr.py exit 2
137 137 # An exception has occurred, use %tb to see the full traceback.
138 138 # SystemExit: (2, 'Mode = exit')
139 139 #
140 140 # In [20]: %tb
141 141 # Traceback (most recent call last):
142 142 # File ... in <module>
143 143 # bar(mode)
144 144 # File ... line 22, in bar
145 145 # sysexit(stat, mode)
146 146 # File ... line 11, in sysexit
147 147 # raise SystemExit(stat, 'Mode = %s' % mode)
148 148 # SystemExit: (2, 'Mode = exit')
149 149 #
150 150 # In [21]: %xmode context
151 151 # Exception reporting mode: Context
152 152 #
153 153 # In [22]: %tb
154 154 # ---------------------------------------------------------------------------
155 155 # SystemExit Traceback (most recent call last)
156 156 # <BLANKLINE>
157 157 # ...<module>
158 158 # 29 except IndexError:
159 159 # 30 mode = 'div'
160 160 # ---> 32 bar(mode)
161 161 # <BLANKLINE>
162 162 # ...bar(mode)
163 163 # 20 except:
164 164 # 21 stat = 1
165 165 # ---> 22 sysexit(stat, mode)
166 166 # 23 else:
167 167 # 24 raise ValueError('Unknown mode')
168 168 # <BLANKLINE>
169 169 # ...sysexit(stat, mode)
170 170 # 10 def sysexit(stat, mode):
171 171 # ---> 11 raise SystemExit(stat, 'Mode = %s' % mode)
172 172 # <BLANKLINE>
173 173 # SystemExit: (2, 'Mode = exit')
174 174 #
175 175 # In [23]: %xmode verbose
176 176 # Exception reporting mode: Verbose
177 177 #
178 178 # In [24]: %tb
179 179 # ---------------------------------------------------------------------------
180 180 # SystemExit Traceback (most recent call last)
181 181 # <BLANKLINE>
182 182 # ... in <module>
183 183 # 29 except IndexError:
184 184 # 30 mode = 'div'
185 185 # ---> 32 bar(mode)
186 186 # mode = 'exit'
187 187 # <BLANKLINE>
188 188 # ... in bar(mode='exit')
189 189 # 20 except:
190 190 # 21 stat = 1
191 191 # ---> 22 sysexit(stat, mode)
192 192 # mode = 'exit'
193 193 # stat = 2
194 194 # 23 else:
195 195 # 24 raise ValueError('Unknown mode')
196 196 # <BLANKLINE>
197 197 # ... in sysexit(stat=2, mode='exit')
198 198 # 10 def sysexit(stat, mode):
199 199 # ---> 11 raise SystemExit(stat, 'Mode = %s' % mode)
200 200 # stat = 2
201 201 # mode = 'exit'
202 202 # <BLANKLINE>
203 203 # SystemExit: (2, 'Mode = exit')
204 204 # """
205 205
206 206
207 207 def test_run_cell():
208 208 import textwrap
209 209 ip.run_cell('a = 10\na+=1')
210 210 ip.run_cell('assert a == 11\nassert 1')
211 211
212 nt.assert_equal(ip.user_ns['a'], 11)
212 assert ip.user_ns['a'] == 11
213 213 complex = textwrap.dedent("""
214 214 if 1:
215 215 print "hello"
216 216 if 1:
217 217 print "world"
218 218
219 219 if 2:
220 220 print "foo"
221 221
222 222 if 3:
223 223 print "bar"
224 224
225 225 if 4:
226 226 print "bar"
227 227
228 228 """)
229 229 # Simply verifies that this kind of input is run
230 230 ip.run_cell(complex)
231 231
232 232
233 233 def test_db():
234 234 """Test the internal database used for variable persistence."""
235 235 ip.db['__unittest_'] = 12
236 nt.assert_equal(ip.db['__unittest_'], 12)
236 assert ip.db['__unittest_'] == 12
237 237 del ip.db['__unittest_']
238 238 assert '__unittest_' not in ip.db
@@ -1,30 +1,30
1 1 # -*- coding: utf-8 -*-
2 2 """Test IPython.core.logger"""
3 3
4 4 import os.path
5 import pytest
5 6
6 import nose.tools as nt
7 7 from IPython.utils.tempdir import TemporaryDirectory
8 8
9 9 def test_logstart_inaccessible_file():
10 10 try:
11 11 _ip.logger.logstart(logfname="/") # Opening that filename will fail.
12 12 except IOError:
13 13 pass
14 14 else:
15 nt.assert_true(False) # The try block should never pass.
15 assert False # The try block should never pass.
16 16
17 17 try:
18 18 _ip.run_cell("a=1") # Check it doesn't try to log this
19 19 finally:
20 20 _ip.logger.log_active = False # If this fails, don't let later tests fail
21 21
22 22 def test_logstart_unicode():
23 23 with TemporaryDirectory() as tdir:
24 24 logfname = os.path.join(tdir, "test_unicode.log")
25 25 _ip.run_cell("'abc€'")
26 26 try:
27 27 _ip.magic("logstart -to %s" % logfname)
28 28 _ip.run_cell("'abc€'")
29 29 finally:
30 30 _ip.logger.logstop()
@@ -1,118 +1,118
1 1 #-----------------------------------------------------------------------------
2 2 # Copyright (C) 2010-2011, IPython Development Team.
3 3 #
4 4 # Distributed under the terms of the Modified BSD License.
5 5 #
6 6 # The full license is in the file COPYING.txt, distributed with this software.
7 7 #-----------------------------------------------------------------------------
8 8
9 9 import argparse
10 from nose.tools import assert_equal
10 import pytest
11 11
12 12 from IPython.core.magic_arguments import (argument, argument_group, kwds,
13 13 magic_arguments, parse_argstring, real_name)
14 14
15 15
16 16 @magic_arguments()
17 17 @argument('-f', '--foo', help="an argument")
18 18 def magic_foo1(self, args):
19 19 """ A docstring.
20 20 """
21 21 return parse_argstring(magic_foo1, args)
22 22
23 23
24 24 @magic_arguments()
25 25 def magic_foo2(self, args):
26 26 """ A docstring.
27 27 """
28 28 return parse_argstring(magic_foo2, args)
29 29
30 30
31 31 @magic_arguments()
32 32 @argument('-f', '--foo', help="an argument")
33 33 @argument_group('Group')
34 34 @argument('-b', '--bar', help="a grouped argument")
35 35 @argument_group('Second Group')
36 36 @argument('-z', '--baz', help="another grouped argument")
37 37 def magic_foo3(self, args):
38 38 """ A docstring.
39 39 """
40 40 return parse_argstring(magic_foo3, args)
41 41
42 42
43 43 @magic_arguments()
44 44 @kwds(argument_default=argparse.SUPPRESS)
45 45 @argument('-f', '--foo', help="an argument")
46 46 def magic_foo4(self, args):
47 47 """ A docstring.
48 48 """
49 49 return parse_argstring(magic_foo4, args)
50 50
51 51
52 52 @magic_arguments('frobnicate')
53 53 @argument('-f', '--foo', help="an argument")
54 54 def magic_foo5(self, args):
55 55 """ A docstring.
56 56 """
57 57 return parse_argstring(magic_foo5, args)
58 58
59 59
60 60 @magic_arguments()
61 61 @argument('-f', '--foo', help="an argument")
62 62 def magic_magic_foo(self, args):
63 63 """ A docstring.
64 64 """
65 65 return parse_argstring(magic_magic_foo, args)
66 66
67 67
68 68 @magic_arguments()
69 69 @argument('-f', '--foo', help="an argument")
70 70 def foo(self, args):
71 71 """ A docstring.
72 72 """
73 73 return parse_argstring(foo, args)
74 74
75 75
76 76 def test_magic_arguments():
77 assert_equal(magic_foo1.__doc__, '::\n\n %foo1 [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n')
78 assert_equal(getattr(magic_foo1, 'argcmd_name', None), None)
79 assert_equal(real_name(magic_foo1), 'foo1')
80 assert_equal(magic_foo1(None, ''), argparse.Namespace(foo=None))
77 assert magic_foo1.__doc__ == '::\n\n %foo1 [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n'
78 assert getattr(magic_foo1, 'argcmd_name', None) == None
79 assert real_name(magic_foo1) == 'foo1'
80 assert magic_foo1(None, '') == argparse.Namespace(foo=None)
81 81 assert hasattr(magic_foo1, 'has_arguments')
82 82
83 assert_equal(magic_foo2.__doc__, '::\n\n %foo2\n\n A docstring.\n')
84 assert_equal(getattr(magic_foo2, 'argcmd_name', None), None)
85 assert_equal(real_name(magic_foo2), 'foo2')
86 assert_equal(magic_foo2(None, ''), argparse.Namespace())
83 assert magic_foo2.__doc__ == '::\n\n %foo2\n\n A docstring.\n'
84 assert getattr(magic_foo2, 'argcmd_name', None) == None
85 assert real_name(magic_foo2) == 'foo2'
86 assert magic_foo2(None, '') == argparse.Namespace()
87 87 assert hasattr(magic_foo2, 'has_arguments')
88 88
89 assert_equal(magic_foo3.__doc__, '::\n\n %foo3 [-f FOO] [-b BAR] [-z BAZ]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n\nGroup:\n -b BAR, --bar BAR a grouped argument\n\nSecond Group:\n -z BAZ, --baz BAZ another grouped argument\n')
90 assert_equal(getattr(magic_foo3, 'argcmd_name', None), None)
91 assert_equal(real_name(magic_foo3), 'foo3')
92 assert_equal(magic_foo3(None, ''),
89 assert magic_foo3.__doc__ == '::\n\n %foo3 [-f FOO] [-b BAR] [-z BAZ]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n\nGroup:\n -b BAR, --bar BAR a grouped argument\n\nSecond Group:\n -z BAZ, --baz BAZ another grouped argument\n'
90 assert getattr(magic_foo3, 'argcmd_name', None) == None
91 assert real_name(magic_foo3) == 'foo3'
92 assert (magic_foo3(None, '') ==
93 93 argparse.Namespace(bar=None, baz=None, foo=None))
94 94 assert hasattr(magic_foo3, 'has_arguments')
95 95
96 assert_equal(magic_foo4.__doc__, '::\n\n %foo4 [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n')
97 assert_equal(getattr(magic_foo4, 'argcmd_name', None), None)
98 assert_equal(real_name(magic_foo4), 'foo4')
99 assert_equal(magic_foo4(None, ''), argparse.Namespace())
96 assert magic_foo4.__doc__ == '::\n\n %foo4 [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n'
97 assert getattr(magic_foo4, 'argcmd_name', None) == None
98 assert real_name(magic_foo4) == 'foo4'
99 assert magic_foo4(None, '') == argparse.Namespace()
100 100 assert hasattr(magic_foo4, 'has_arguments')
101 101
102 assert_equal(magic_foo5.__doc__, '::\n\n %frobnicate [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n')
103 assert_equal(getattr(magic_foo5, 'argcmd_name', None), 'frobnicate')
104 assert_equal(real_name(magic_foo5), 'frobnicate')
105 assert_equal(magic_foo5(None, ''), argparse.Namespace(foo=None))
102 assert magic_foo5.__doc__ == '::\n\n %frobnicate [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n'
103 assert getattr(magic_foo5, 'argcmd_name', None) == 'frobnicate'
104 assert real_name(magic_foo5) == 'frobnicate'
105 assert magic_foo5(None, '') == argparse.Namespace(foo=None)
106 106 assert hasattr(magic_foo5, 'has_arguments')
107 107
108 assert_equal(magic_magic_foo.__doc__, '::\n\n %magic_foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n')
109 assert_equal(getattr(magic_magic_foo, 'argcmd_name', None), None)
110 assert_equal(real_name(magic_magic_foo), 'magic_foo')
111 assert_equal(magic_magic_foo(None, ''), argparse.Namespace(foo=None))
108 assert magic_magic_foo.__doc__ == '::\n\n %magic_foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n'
109 assert getattr(magic_magic_foo, 'argcmd_name', None) == None
110 assert real_name(magic_magic_foo) == 'magic_foo'
111 assert magic_magic_foo(None, '') == argparse.Namespace(foo=None)
112 112 assert hasattr(magic_magic_foo, 'has_arguments')
113 113
114 assert_equal(foo.__doc__, '::\n\n %foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n')
115 assert_equal(getattr(foo, 'argcmd_name', None), None)
116 assert_equal(real_name(foo), 'foo')
117 assert_equal(foo(None, ''), argparse.Namespace(foo=None))
114 assert foo.__doc__ == '::\n\n %foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n -f FOO, --foo FOO an argument\n'
115 assert getattr(foo, 'argcmd_name', None) == None
116 assert real_name(foo) == 'foo'
117 assert foo(None, '') == argparse.Namespace(foo=None)
118 118 assert hasattr(foo, 'has_arguments')
@@ -1,127 +1,127
1 1 """Tests for input manipulation machinery."""
2 2
3 3 #-----------------------------------------------------------------------------
4 4 # Imports
5 5 #-----------------------------------------------------------------------------
6 import nose.tools as nt
6 import pytest
7 7
8 8 from IPython.core.prefilter import AutocallChecker
9 9
10 10 #-----------------------------------------------------------------------------
11 11 # Tests
12 12 #-----------------------------------------------------------------------------
13 13
14 14 def test_prefilter():
15 15 """Test user input conversions"""
16 16
17 17 # pairs of (raw, expected correct) input
18 18 pairs = [ ('2+2','2+2'),
19 19 ]
20 20
21 21 for raw, correct in pairs:
22 nt.assert_equal(ip.prefilter(raw), correct)
22 assert ip.prefilter(raw) == correct
23 23
24 24 def test_prefilter_shadowed():
25 25 def dummy_magic(line): pass
26 26
27 27 prev_automagic_state = ip.automagic
28 28 ip.automagic = True
29 29 ip.autocall = 0
30 30
31 31 try:
32 32 # These should not be transformed - they are shadowed by other names
33 33 for name in ['if', 'zip', 'get_ipython']: # keyword, builtin, global
34 34 ip.register_magic_function(dummy_magic, magic_name=name)
35 35 res = ip.prefilter(name+' foo')
36 nt.assert_equal(res, name+' foo')
36 assert res == name+' foo'
37 37 del ip.magics_manager.magics['line'][name]
38 38
39 39 # These should be transformed
40 40 for name in ['fi', 'piz', 'nohtypi_teg']:
41 41 ip.register_magic_function(dummy_magic, magic_name=name)
42 42 res = ip.prefilter(name+' foo')
43 nt.assert_not_equal(res, name+' foo')
43 assert res != name+' foo'
44 44 del ip.magics_manager.magics['line'][name]
45 45
46 46 finally:
47 47 ip.automagic = prev_automagic_state
48 48
49 49 def test_autocall_binops():
50 50 """See https://github.com/ipython/ipython/issues/81"""
51 51 ip.magic('autocall 2')
52 52 f = lambda x: x
53 53 ip.user_ns['f'] = f
54 54 try:
55 nt.assert_equal(ip.prefilter('f 1'),'f(1)')
55 assert ip.prefilter('f 1') =='f(1)'
56 56 for t in ['f +1', 'f -1']:
57 nt.assert_equal(ip.prefilter(t), t)
57 assert ip.prefilter(t) == t
58 58
59 59 # Run tests again with a more permissive exclude_regexp, which will
60 60 # allow transformation of binary operations ('f -1' -> 'f(-1)').
61 61 pm = ip.prefilter_manager
62 62 ac = AutocallChecker(shell=pm.shell, prefilter_manager=pm,
63 63 config=pm.config)
64 64 try:
65 65 ac.priority = 1
66 66 ac.exclude_regexp = r'^[,&^\|\*/]|^is |^not |^in |^and |^or '
67 67 pm.sort_checkers()
68 68
69 nt.assert_equal(ip.prefilter('f -1'), 'f(-1)')
70 nt.assert_equal(ip.prefilter('f +1'), 'f(+1)')
69 assert ip.prefilter('f -1') == 'f(-1)'
70 assert ip.prefilter('f +1') == 'f(+1)'
71 71 finally:
72 72 pm.unregister_checker(ac)
73 73 finally:
74 74 ip.magic('autocall 0')
75 75 del ip.user_ns['f']
76 76
77 77
78 78 def test_issue_114():
79 79 """Check that multiline string literals don't expand as magic
80 80 see http://github.com/ipython/ipython/issues/114"""
81 81
82 82 template = '"""\n%s\n"""'
83 83 # Store the current value of multi_line_specials and turn it off before
84 84 # running test, since it could be true (case in which the test doesn't make
85 85 # sense, as multiline string literals *will* expand as magic in that case).
86 86 msp = ip.prefilter_manager.multi_line_specials
87 87 ip.prefilter_manager.multi_line_specials = False
88 88 try:
89 89 for mgk in ip.magics_manager.lsmagic()['line']:
90 90 raw = template % mgk
91 nt.assert_equal(ip.prefilter(raw), raw)
91 assert ip.prefilter(raw) == raw
92 92 finally:
93 93 ip.prefilter_manager.multi_line_specials = msp
94 94
95 95
96 96 def test_prefilter_attribute_errors():
97 97 """Capture exceptions thrown by user objects on attribute access.
98 98
99 99 See http://github.com/ipython/ipython/issues/988."""
100 100
101 101 class X(object):
102 102 def __getattr__(self, k):
103 103 raise ValueError('broken object')
104 104 def __call__(self, x):
105 105 return x
106 106
107 107 # Create a callable broken object
108 108 ip.user_ns['x'] = X()
109 109 ip.magic('autocall 2')
110 110 try:
111 111 # Even if x throws an attribute error when looking at its rewrite
112 112 # attribute, we should not crash. So the test here is simply making
113 113 # the prefilter call and not having an exception.
114 114 ip.prefilter('x 1')
115 115 finally:
116 116 del ip.user_ns['x']
117 117 ip.magic('autocall 0')
118 118
119 119
120 120 def test_autocall_should_support_unicode():
121 121 ip.magic('autocall 2')
122 122 ip.user_ns['π'] = lambda x: x
123 123 try:
124 nt.assert_equal(ip.prefilter('π 3'),'π(3)')
124 assert ip.prefilter('π 3') =='π(3)'
125 125 finally:
126 126 ip.magic('autocall 0')
127 127 del ip.user_ns['π']
General Comments 0
You need to be logged in to leave comments. Login now