##// END OF EJS Templates
test first element of sys.path in Kernel...
MinRK -
Show More
@@ -1,170 +1,186
1 """test the IPython Kernel"""
1 """test the IPython Kernel"""
2
2
3 #-------------------------------------------------------------------------------
3 #-------------------------------------------------------------------------------
4 # Copyright (C) 2013 The IPython Development Team
4 # Copyright (C) 2013 The IPython Development Team
5 #
5 #
6 # Distributed under the terms of the BSD License. The full license is in
6 # Distributed under the terms of the BSD License. The full license is in
7 # the file COPYING, distributed as part of this software.
7 # the file COPYING, distributed as part of this software.
8 #-------------------------------------------------------------------------------
8 #-------------------------------------------------------------------------------
9
9
10 #-------------------------------------------------------------------------------
10 #-------------------------------------------------------------------------------
11 # Imports
11 # Imports
12 #-------------------------------------------------------------------------------
12 #-------------------------------------------------------------------------------
13
13
14 import sys
14 import sys
15
15
16 import nose.tools as nt
16 import nose.tools as nt
17
17
18 from IPython.testing import decorators as dec, tools as tt
18 from IPython.testing import decorators as dec, tools as tt
19 from IPython.utils import py3compat
19 from IPython.utils import py3compat
20 from IPython.utils.path import locate_profile
20
21
21 from .utils import new_kernel, kernel, TIMEOUT, assemble_output, execute, flush_channels
22 from .utils import new_kernel, kernel, TIMEOUT, assemble_output, execute, flush_channels
22
23
23 #-------------------------------------------------------------------------------
24 #-------------------------------------------------------------------------------
24 # Tests
25 # Tests
25 #-------------------------------------------------------------------------------
26 #-------------------------------------------------------------------------------
26
27
27
28
28 def _check_mp_mode(kc, expected=False, stream="stdout"):
29 def _check_mp_mode(kc, expected=False, stream="stdout"):
29 execute(kc=kc, code="import sys")
30 execute(kc=kc, code="import sys")
30 flush_channels(kc)
31 flush_channels(kc)
31 msg_id, content = execute(kc=kc, code="print (sys.%s._check_mp_mode())" % stream)
32 msg_id, content = execute(kc=kc, code="print (sys.%s._check_mp_mode())" % stream)
32 stdout, stderr = assemble_output(kc.iopub_channel)
33 stdout, stderr = assemble_output(kc.iopub_channel)
33 nt.assert_equal(eval(stdout.strip()), expected)
34 nt.assert_equal(eval(stdout.strip()), expected)
34
35
35
36
36 # printing tests
37 # printing tests
37
38
38 def test_simple_print():
39 def test_simple_print():
39 """simple print statement in kernel"""
40 """simple print statement in kernel"""
40 with kernel() as kc:
41 with kernel() as kc:
41 iopub = kc.iopub_channel
42 iopub = kc.iopub_channel
42 msg_id, content = execute(kc=kc, code="print ('hi')")
43 msg_id, content = execute(kc=kc, code="print ('hi')")
43 stdout, stderr = assemble_output(iopub)
44 stdout, stderr = assemble_output(iopub)
44 nt.assert_equal(stdout, 'hi\n')
45 nt.assert_equal(stdout, 'hi\n')
45 nt.assert_equal(stderr, '')
46 nt.assert_equal(stderr, '')
46 _check_mp_mode(kc, expected=False)
47 _check_mp_mode(kc, expected=False)
47
48
48
49
50 def test_sys_path():
51 """test that sys.path doesn't get messed up by default"""
52 with kernel() as kc:
53 msg_id, content = execute(kc=kc, code="import sys; print (repr(sys.path[0]))")
54 stdout, stderr = assemble_output(kc.iopub_channel)
55 nt.assert_equal(stdout, "''\n")
56
57 def test_sys_path_profile_dir():
58 """test that sys.path doesn't get messed up when `--profile-dir` is specified"""
59
60 with new_kernel(['--profile-dir', locate_profile('default')]) as kc:
61 msg_id, content = execute(kc=kc, code="import sys; print (repr(sys.path[0]))")
62 stdout, stderr = assemble_output(kc.iopub_channel)
63 nt.assert_equal(stdout, "''\n")
64
49 @dec.knownfailureif(sys.platform == 'win32', "subprocess prints fail on Windows")
65 @dec.knownfailureif(sys.platform == 'win32', "subprocess prints fail on Windows")
50 def test_subprocess_print():
66 def test_subprocess_print():
51 """printing from forked mp.Process"""
67 """printing from forked mp.Process"""
52 with new_kernel() as kc:
68 with new_kernel() as kc:
53 iopub = kc.iopub_channel
69 iopub = kc.iopub_channel
54
70
55 _check_mp_mode(kc, expected=False)
71 _check_mp_mode(kc, expected=False)
56 flush_channels(kc)
72 flush_channels(kc)
57 np = 5
73 np = 5
58 code = '\n'.join([
74 code = '\n'.join([
59 "from __future__ import print_function",
75 "from __future__ import print_function",
60 "import multiprocessing as mp",
76 "import multiprocessing as mp",
61 "pool = [mp.Process(target=print, args=('hello', i,)) for i in range(%i)]" % np,
77 "pool = [mp.Process(target=print, args=('hello', i,)) for i in range(%i)]" % np,
62 "for p in pool: p.start()",
78 "for p in pool: p.start()",
63 "for p in pool: p.join()"
79 "for p in pool: p.join()"
64 ])
80 ])
65
81
66 expected = '\n'.join([
82 expected = '\n'.join([
67 "hello %s" % i for i in range(np)
83 "hello %s" % i for i in range(np)
68 ]) + '\n'
84 ]) + '\n'
69
85
70 msg_id, content = execute(kc=kc, code=code)
86 msg_id, content = execute(kc=kc, code=code)
71 stdout, stderr = assemble_output(iopub)
87 stdout, stderr = assemble_output(iopub)
72 nt.assert_equal(stdout.count("hello"), np, stdout)
88 nt.assert_equal(stdout.count("hello"), np, stdout)
73 for n in range(np):
89 for n in range(np):
74 nt.assert_equal(stdout.count(str(n)), 1, stdout)
90 nt.assert_equal(stdout.count(str(n)), 1, stdout)
75 nt.assert_equal(stderr, '')
91 nt.assert_equal(stderr, '')
76 _check_mp_mode(kc, expected=False)
92 _check_mp_mode(kc, expected=False)
77 _check_mp_mode(kc, expected=False, stream="stderr")
93 _check_mp_mode(kc, expected=False, stream="stderr")
78
94
79
95
80 def test_subprocess_noprint():
96 def test_subprocess_noprint():
81 """mp.Process without print doesn't trigger iostream mp_mode"""
97 """mp.Process without print doesn't trigger iostream mp_mode"""
82 with kernel() as kc:
98 with kernel() as kc:
83 iopub = kc.iopub_channel
99 iopub = kc.iopub_channel
84
100
85 np = 5
101 np = 5
86 code = '\n'.join([
102 code = '\n'.join([
87 "import multiprocessing as mp",
103 "import multiprocessing as mp",
88 "pool = [mp.Process(target=range, args=(i,)) for i in range(%i)]" % np,
104 "pool = [mp.Process(target=range, args=(i,)) for i in range(%i)]" % np,
89 "for p in pool: p.start()",
105 "for p in pool: p.start()",
90 "for p in pool: p.join()"
106 "for p in pool: p.join()"
91 ])
107 ])
92
108
93 msg_id, content = execute(kc=kc, code=code)
109 msg_id, content = execute(kc=kc, code=code)
94 stdout, stderr = assemble_output(iopub)
110 stdout, stderr = assemble_output(iopub)
95 nt.assert_equal(stdout, '')
111 nt.assert_equal(stdout, '')
96 nt.assert_equal(stderr, '')
112 nt.assert_equal(stderr, '')
97
113
98 _check_mp_mode(kc, expected=False)
114 _check_mp_mode(kc, expected=False)
99 _check_mp_mode(kc, expected=False, stream="stderr")
115 _check_mp_mode(kc, expected=False, stream="stderr")
100
116
101
117
102 @dec.knownfailureif(sys.platform == 'win32', "subprocess prints fail on Windows")
118 @dec.knownfailureif(sys.platform == 'win32', "subprocess prints fail on Windows")
103 def test_subprocess_error():
119 def test_subprocess_error():
104 """error in mp.Process doesn't crash"""
120 """error in mp.Process doesn't crash"""
105 with new_kernel() as kc:
121 with new_kernel() as kc:
106 iopub = kc.iopub_channel
122 iopub = kc.iopub_channel
107
123
108 code = '\n'.join([
124 code = '\n'.join([
109 "import multiprocessing as mp",
125 "import multiprocessing as mp",
110 "p = mp.Process(target=int, args=('hi',))",
126 "p = mp.Process(target=int, args=('hi',))",
111 "p.start()",
127 "p.start()",
112 "p.join()",
128 "p.join()",
113 ])
129 ])
114
130
115 msg_id, content = execute(kc=kc, code=code)
131 msg_id, content = execute(kc=kc, code=code)
116 stdout, stderr = assemble_output(iopub)
132 stdout, stderr = assemble_output(iopub)
117 nt.assert_equal(stdout, '')
133 nt.assert_equal(stdout, '')
118 nt.assert_true("ValueError" in stderr, stderr)
134 nt.assert_true("ValueError" in stderr, stderr)
119
135
120 _check_mp_mode(kc, expected=False)
136 _check_mp_mode(kc, expected=False)
121 _check_mp_mode(kc, expected=False, stream="stderr")
137 _check_mp_mode(kc, expected=False, stream="stderr")
122
138
123 # raw_input tests
139 # raw_input tests
124
140
125 def test_raw_input():
141 def test_raw_input():
126 """test [raw_]input"""
142 """test [raw_]input"""
127 with kernel() as kc:
143 with kernel() as kc:
128 iopub = kc.iopub_channel
144 iopub = kc.iopub_channel
129
145
130 input_f = "input" if py3compat.PY3 else "raw_input"
146 input_f = "input" if py3compat.PY3 else "raw_input"
131 theprompt = "prompt> "
147 theprompt = "prompt> "
132 code = 'print({input_f}("{theprompt}"))'.format(**locals())
148 code = 'print({input_f}("{theprompt}"))'.format(**locals())
133 msg_id = kc.execute(code, allow_stdin=True)
149 msg_id = kc.execute(code, allow_stdin=True)
134 msg = kc.get_stdin_msg(block=True, timeout=TIMEOUT)
150 msg = kc.get_stdin_msg(block=True, timeout=TIMEOUT)
135 nt.assert_equal(msg['header']['msg_type'], u'input_request')
151 nt.assert_equal(msg['header']['msg_type'], u'input_request')
136 content = msg['content']
152 content = msg['content']
137 nt.assert_equal(content['prompt'], theprompt)
153 nt.assert_equal(content['prompt'], theprompt)
138 text = "some text"
154 text = "some text"
139 kc.input(text)
155 kc.input(text)
140 reply = kc.get_shell_msg(block=True, timeout=TIMEOUT)
156 reply = kc.get_shell_msg(block=True, timeout=TIMEOUT)
141 nt.assert_equal(reply['content']['status'], 'ok')
157 nt.assert_equal(reply['content']['status'], 'ok')
142 stdout, stderr = assemble_output(iopub)
158 stdout, stderr = assemble_output(iopub)
143 nt.assert_equal(stdout, text + "\n")
159 nt.assert_equal(stdout, text + "\n")
144
160
145
161
146 @dec.skipif(py3compat.PY3)
162 @dec.skipif(py3compat.PY3)
147 def test_eval_input():
163 def test_eval_input():
148 """test input() on Python 2"""
164 """test input() on Python 2"""
149 with kernel() as kc:
165 with kernel() as kc:
150 iopub = kc.iopub_channel
166 iopub = kc.iopub_channel
151
167
152 input_f = "input" if py3compat.PY3 else "raw_input"
168 input_f = "input" if py3compat.PY3 else "raw_input"
153 theprompt = "prompt> "
169 theprompt = "prompt> "
154 code = 'print(input("{theprompt}"))'.format(**locals())
170 code = 'print(input("{theprompt}"))'.format(**locals())
155 msg_id = kc.execute(code, allow_stdin=True)
171 msg_id = kc.execute(code, allow_stdin=True)
156 msg = kc.get_stdin_msg(block=True, timeout=TIMEOUT)
172 msg = kc.get_stdin_msg(block=True, timeout=TIMEOUT)
157 nt.assert_equal(msg['header']['msg_type'], u'input_request')
173 nt.assert_equal(msg['header']['msg_type'], u'input_request')
158 content = msg['content']
174 content = msg['content']
159 nt.assert_equal(content['prompt'], theprompt)
175 nt.assert_equal(content['prompt'], theprompt)
160 kc.input("1+1")
176 kc.input("1+1")
161 reply = kc.get_shell_msg(block=True, timeout=TIMEOUT)
177 reply = kc.get_shell_msg(block=True, timeout=TIMEOUT)
162 nt.assert_equal(reply['content']['status'], 'ok')
178 nt.assert_equal(reply['content']['status'], 'ok')
163 stdout, stderr = assemble_output(iopub)
179 stdout, stderr = assemble_output(iopub)
164 nt.assert_equal(stdout, "2\n")
180 nt.assert_equal(stdout, "2\n")
165
181
166
182
167 def test_help_output():
183 def test_help_output():
168 """ipython kernel --help-all works"""
184 """ipython kernel --help-all works"""
169 tt.help_all_output_test('kernel')
185 tt.help_all_output_test('kernel')
170
186
@@ -1,167 +1,170
1 """utilities for testing IPython kernels"""
1 """utilities for testing IPython kernels"""
2
2
3 #-------------------------------------------------------------------------------
3 #-------------------------------------------------------------------------------
4 # Copyright (C) 2013 The IPython Development Team
4 # Copyright (C) 2013 The IPython Development Team
5 #
5 #
6 # Distributed under the terms of the BSD License. The full license is in
6 # Distributed under the terms of the BSD License. The full license is in
7 # the file COPYING, distributed as part of this software.
7 # the file COPYING, distributed as part of this software.
8 #-------------------------------------------------------------------------------
8 #-------------------------------------------------------------------------------
9
9
10 #-------------------------------------------------------------------------------
10 #-------------------------------------------------------------------------------
11 # Imports
11 # Imports
12 #-------------------------------------------------------------------------------
12 #-------------------------------------------------------------------------------
13
13
14 import atexit
14 import atexit
15
15
16 from contextlib import contextmanager
16 from contextlib import contextmanager
17 from subprocess import PIPE
17 from subprocess import PIPE
18 from Queue import Empty
18 from Queue import Empty
19
19
20 import nose.tools as nt
20 import nose.tools as nt
21
21
22 from IPython.kernel import KernelManager
22 from IPython.kernel import KernelManager
23
23
24 #-------------------------------------------------------------------------------
24 #-------------------------------------------------------------------------------
25 # Globals
25 # Globals
26 #-------------------------------------------------------------------------------
26 #-------------------------------------------------------------------------------
27
27
28 STARTUP_TIMEOUT = 60
28 STARTUP_TIMEOUT = 60
29 TIMEOUT = 15
29 TIMEOUT = 15
30
30
31 KM = None
31 KM = None
32 KC = None
32 KC = None
33
33
34 #-------------------------------------------------------------------------------
34 #-------------------------------------------------------------------------------
35 # code
35 # code
36 #-------------------------------------------------------------------------------
36 #-------------------------------------------------------------------------------
37
37
38
38
39 def start_new_kernel():
39 def start_new_kernel(argv=None):
40 """start a new kernel, and return its Manager and Client"""
40 """start a new kernel, and return its Manager and Client"""
41 km = KernelManager()
41 km = KernelManager()
42 km.start_kernel(stdout=PIPE, stderr=PIPE)
42 kwargs = dict(stdout=PIPE, stderr=PIPE)
43 if argv:
44 kwargs['extra_arguments'] = argv
45 km.start_kernel(**kwargs)
43 kc = km.client()
46 kc = km.client()
44 kc.start_channels()
47 kc.start_channels()
45
48
46 msg_id = kc.kernel_info()
49 msg_id = kc.kernel_info()
47 kc.get_shell_msg(block=True, timeout=STARTUP_TIMEOUT)
50 kc.get_shell_msg(block=True, timeout=STARTUP_TIMEOUT)
48 flush_channels(kc)
51 flush_channels(kc)
49 return km, kc
52 return km, kc
50
53
51 def flush_channels(kc=None):
54 def flush_channels(kc=None):
52 """flush any messages waiting on the queue"""
55 """flush any messages waiting on the queue"""
53 from .test_message_spec import validate_message
56 from .test_message_spec import validate_message
54
57
55 if kc is None:
58 if kc is None:
56 kc = KC
59 kc = KC
57 for channel in (kc.shell_channel, kc.iopub_channel):
60 for channel in (kc.shell_channel, kc.iopub_channel):
58 while True:
61 while True:
59 try:
62 try:
60 msg = channel.get_msg(block=True, timeout=0.1)
63 msg = channel.get_msg(block=True, timeout=0.1)
61 except Empty:
64 except Empty:
62 break
65 break
63 else:
66 else:
64 validate_message(msg)
67 validate_message(msg)
65
68
66
69
67 def execute(code='', kc=None, **kwargs):
70 def execute(code='', kc=None, **kwargs):
68 """wrapper for doing common steps for validating an execution request"""
71 """wrapper for doing common steps for validating an execution request"""
69 from .test_message_spec import validate_message
72 from .test_message_spec import validate_message
70 if kc is None:
73 if kc is None:
71 kc = KC
74 kc = KC
72 msg_id = kc.execute(code=code, **kwargs)
75 msg_id = kc.execute(code=code, **kwargs)
73 reply = kc.get_shell_msg(timeout=TIMEOUT)
76 reply = kc.get_shell_msg(timeout=TIMEOUT)
74 validate_message(reply, 'execute_reply', msg_id)
77 validate_message(reply, 'execute_reply', msg_id)
75 busy = kc.get_iopub_msg(timeout=TIMEOUT)
78 busy = kc.get_iopub_msg(timeout=TIMEOUT)
76 validate_message(busy, 'status', msg_id)
79 validate_message(busy, 'status', msg_id)
77 nt.assert_equal(busy['content']['execution_state'], 'busy')
80 nt.assert_equal(busy['content']['execution_state'], 'busy')
78
81
79 if not kwargs.get('silent'):
82 if not kwargs.get('silent'):
80 pyin = kc.get_iopub_msg(timeout=TIMEOUT)
83 pyin = kc.get_iopub_msg(timeout=TIMEOUT)
81 validate_message(pyin, 'pyin', msg_id)
84 validate_message(pyin, 'pyin', msg_id)
82 nt.assert_equal(pyin['content']['code'], code)
85 nt.assert_equal(pyin['content']['code'], code)
83
86
84 return msg_id, reply['content']
87 return msg_id, reply['content']
85
88
86 def start_global_kernel():
89 def start_global_kernel():
87 """start the global kernel (if it isn't running) and return its client"""
90 """start the global kernel (if it isn't running) and return its client"""
88 global KM, KC
91 global KM, KC
89 if KM is None:
92 if KM is None:
90 KM, KC = start_new_kernel()
93 KM, KC = start_new_kernel()
91 atexit.register(stop_global_kernel)
94 atexit.register(stop_global_kernel)
92 return KC
95 return KC
93
96
94 @contextmanager
97 @contextmanager
95 def kernel():
98 def kernel():
96 """Context manager for the global kernel instance
99 """Context manager for the global kernel instance
97
100
98 Should be used for most kernel tests
101 Should be used for most kernel tests
99
102
100 Returns
103 Returns
101 -------
104 -------
102 kernel_client: connected KernelClient instance
105 kernel_client: connected KernelClient instance
103 """
106 """
104 yield start_global_kernel()
107 yield start_global_kernel()
105
108
106 def uses_kernel(test_f):
109 def uses_kernel(test_f):
107 """Decorator for tests that use the global kernel"""
110 """Decorator for tests that use the global kernel"""
108 def wrapped_test():
111 def wrapped_test():
109 with kernel() as kc:
112 with kernel() as kc:
110 test_f(kc)
113 test_f(kc)
111 wrapped_test.__doc__ = test_f.__doc__
114 wrapped_test.__doc__ = test_f.__doc__
112 wrapped_test.__name__ = test_f.__name__
115 wrapped_test.__name__ = test_f.__name__
113 return wrapped_test
116 return wrapped_test
114
117
115 def stop_global_kernel():
118 def stop_global_kernel():
116 """Stop the global shared kernel instance, if it exists"""
119 """Stop the global shared kernel instance, if it exists"""
117 global KM, KC
120 global KM, KC
118 KC.stop_channels()
121 KC.stop_channels()
119 KC = None
122 KC = None
120 if KM is None:
123 if KM is None:
121 return
124 return
122 KM.shutdown_kernel(now=True)
125 KM.shutdown_kernel(now=True)
123 KM = None
126 KM = None
124
127
125 @contextmanager
128 @contextmanager
126 def new_kernel():
129 def new_kernel(argv=None):
127 """Context manager for a new kernel in a subprocess
130 """Context manager for a new kernel in a subprocess
128
131
129 Should only be used for tests where the kernel must not be re-used.
132 Should only be used for tests where the kernel must not be re-used.
130
133
131 Returns
134 Returns
132 -------
135 -------
133 kernel_client: connected KernelClient instance
136 kernel_client: connected KernelClient instance
134 """
137 """
135 km, kc = start_new_kernel()
138 km, kc = start_new_kernel(argv)
136 try:
139 try:
137 yield kc
140 yield kc
138 finally:
141 finally:
139 kc.stop_channels()
142 kc.stop_channels()
140 km.shutdown_kernel(now=True)
143 km.shutdown_kernel(now=True)
141
144
142
145
143 def assemble_output(iopub):
146 def assemble_output(iopub):
144 """assemble stdout/err from an execution"""
147 """assemble stdout/err from an execution"""
145 stdout = ''
148 stdout = ''
146 stderr = ''
149 stderr = ''
147 while True:
150 while True:
148 msg = iopub.get_msg(block=True, timeout=1)
151 msg = iopub.get_msg(block=True, timeout=1)
149 msg_type = msg['msg_type']
152 msg_type = msg['msg_type']
150 content = msg['content']
153 content = msg['content']
151 if msg_type == 'status' and content['execution_state'] == 'idle':
154 if msg_type == 'status' and content['execution_state'] == 'idle':
152 # idle message signals end of output
155 # idle message signals end of output
153 break
156 break
154 elif msg['msg_type'] == 'stream':
157 elif msg['msg_type'] == 'stream':
155 if content['name'] == 'stdout':
158 if content['name'] == 'stdout':
156 stdout += content['data']
159 stdout += content['data']
157 elif content['name'] == 'stderr':
160 elif content['name'] == 'stderr':
158 stderr += content['data']
161 stderr += content['data']
159 else:
162 else:
160 raise KeyError("bad stream: %r" % content['name'])
163 raise KeyError("bad stream: %r" % content['name'])
161 else:
164 else:
162 # other output, ignored
165 # other output, ignored
163 pass
166 pass
164 return stdout, stderr
167 return stdout, stderr
165
168
166
169
167
170
General Comments 0
You need to be logged in to leave comments. Login now