Show More
@@ -0,0 +1,246 b'' | |||
|
1 | from contextlib import contextmanager | |
|
2 | import errno | |
|
3 | import os | |
|
4 | import shutil | |
|
5 | import sys | |
|
6 | import tempfile | |
|
7 | import warnings | |
|
8 | ||
|
9 | try: | |
|
10 | reload | |
|
11 | except NameError: # Python 3 | |
|
12 | from imp import reload | |
|
13 | ||
|
14 | from nose import with_setup | |
|
15 | import nose.tools as nt | |
|
16 | ||
|
17 | import IPython | |
|
18 | from IPython import paths | |
|
19 | from IPython.testing.decorators import skip_win32 | |
|
20 | from IPython.utils.tempdir import TemporaryDirectory | |
|
21 | ||
|
22 | env = os.environ | |
|
23 | TMP_TEST_DIR = tempfile.mkdtemp() | |
|
24 | HOME_TEST_DIR = os.path.join(TMP_TEST_DIR, "home_test_dir") | |
|
25 | XDG_TEST_DIR = os.path.join(HOME_TEST_DIR, "xdg_test_dir") | |
|
26 | XDG_CACHE_DIR = os.path.join(HOME_TEST_DIR, "xdg_cache_dir") | |
|
27 | IP_TEST_DIR = os.path.join(HOME_TEST_DIR,'.ipython') | |
|
28 | ||
|
29 | def setup(): | |
|
30 | """Setup testenvironment for the module: | |
|
31 | ||
|
32 | - Adds dummy home dir tree | |
|
33 | """ | |
|
34 | # Do not mask exceptions here. In particular, catching WindowsError is a | |
|
35 | # problem because that exception is only defined on Windows... | |
|
36 | os.makedirs(IP_TEST_DIR) | |
|
37 | os.makedirs(os.path.join(XDG_TEST_DIR, 'ipython')) | |
|
38 | os.makedirs(os.path.join(XDG_CACHE_DIR, 'ipython')) | |
|
39 | ||
|
40 | ||
|
41 | def teardown(): | |
|
42 | """Teardown testenvironment for the module: | |
|
43 | ||
|
44 | - Remove dummy home dir tree | |
|
45 | """ | |
|
46 | # Note: we remove the parent test dir, which is the root of all test | |
|
47 | # subdirs we may have created. Use shutil instead of os.removedirs, so | |
|
48 | # that non-empty directories are all recursively removed. | |
|
49 | shutil.rmtree(TMP_TEST_DIR) | |
|
50 | ||
|
51 | ||
|
52 | def setup_environment(): | |
|
53 | """Setup testenvironment for some functions that are tested | |
|
54 | in this module. In particular this functions stores attributes | |
|
55 | and other things that we need to stub in some test functions. | |
|
56 | This needs to be done on a function level and not module level because | |
|
57 | each testfunction needs a pristine environment. | |
|
58 | """ | |
|
59 | global oldstuff, platformstuff | |
|
60 | oldstuff = (env.copy(), os.name, sys.platform, paths.get_home_dir, IPython.__file__, os.getcwd()) | |
|
61 | ||
|
62 | def teardown_environment(): | |
|
63 | """Restore things that were remembered by the setup_environment function | |
|
64 | """ | |
|
65 | (oldenv, os.name, sys.platform, paths.get_home_dir, IPython.__file__, old_wd) = oldstuff | |
|
66 | os.chdir(old_wd) | |
|
67 | reload(paths) | |
|
68 | ||
|
69 | for key in list(env): | |
|
70 | if key not in oldenv: | |
|
71 | del env[key] | |
|
72 | env.update(oldenv) | |
|
73 | if hasattr(sys, 'frozen'): | |
|
74 | del sys.frozen | |
|
75 | ||
|
76 | # Build decorator that uses the setup_environment/setup_environment | |
|
77 | with_environment = with_setup(setup_environment, teardown_environment) | |
|
78 | ||
|
79 | @contextmanager | |
|
80 | def patch_get_home_dir(dirpath): | |
|
81 | orig_get_home_dir = paths.get_home_dir | |
|
82 | paths.get_home_dir = lambda : dirpath | |
|
83 | try: | |
|
84 | yield | |
|
85 | finally: | |
|
86 | paths.get_home_dir = orig_get_home_dir | |
|
87 | ||
|
88 | ||
|
89 | @with_environment | |
|
90 | def test_get_ipython_dir_1(): | |
|
91 | """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions.""" | |
|
92 | env_ipdir = os.path.join("someplace", ".ipython") | |
|
93 | paths._writable_dir = lambda path: True | |
|
94 | env['IPYTHONDIR'] = env_ipdir | |
|
95 | ipdir = paths.get_ipython_dir() | |
|
96 | nt.assert_equal(ipdir, env_ipdir) | |
|
97 | ||
|
98 | ||
|
99 | @with_environment | |
|
100 | def test_get_ipython_dir_2(): | |
|
101 | """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions.""" | |
|
102 | with patch_get_home_dir('someplace'): | |
|
103 | paths.get_xdg_dir = lambda : None | |
|
104 | paths._writable_dir = lambda path: True | |
|
105 | os.name = "posix" | |
|
106 | env.pop('IPYTHON_DIR', None) | |
|
107 | env.pop('IPYTHONDIR', None) | |
|
108 | env.pop('XDG_CONFIG_HOME', None) | |
|
109 | ipdir = paths.get_ipython_dir() | |
|
110 | nt.assert_equal(ipdir, os.path.join("someplace", ".ipython")) | |
|
111 | ||
|
112 | @with_environment | |
|
113 | def test_get_ipython_dir_3(): | |
|
114 | """test_get_ipython_dir_3, move XDG if defined, and .ipython doesn't exist.""" | |
|
115 | tmphome = TemporaryDirectory() | |
|
116 | try: | |
|
117 | with patch_get_home_dir(tmphome.name): | |
|
118 | os.name = "posix" | |
|
119 | env.pop('IPYTHON_DIR', None) | |
|
120 | env.pop('IPYTHONDIR', None) | |
|
121 | env['XDG_CONFIG_HOME'] = XDG_TEST_DIR | |
|
122 | ||
|
123 | with warnings.catch_warnings(record=True) as w: | |
|
124 | ipdir = paths.get_ipython_dir() | |
|
125 | ||
|
126 | nt.assert_equal(ipdir, os.path.join(tmphome.name, ".ipython")) | |
|
127 | if sys.platform != 'darwin': | |
|
128 | nt.assert_equal(len(w), 1) | |
|
129 | nt.assert_in('Moving', str(w[0])) | |
|
130 | finally: | |
|
131 | tmphome.cleanup() | |
|
132 | ||
|
133 | @with_environment | |
|
134 | def test_get_ipython_dir_4(): | |
|
135 | """test_get_ipython_dir_4, warn if XDG and home both exist.""" | |
|
136 | with patch_get_home_dir(HOME_TEST_DIR): | |
|
137 | os.name = "posix" | |
|
138 | env.pop('IPYTHON_DIR', None) | |
|
139 | env.pop('IPYTHONDIR', None) | |
|
140 | env['XDG_CONFIG_HOME'] = XDG_TEST_DIR | |
|
141 | try: | |
|
142 | os.mkdir(os.path.join(XDG_TEST_DIR, 'ipython')) | |
|
143 | except OSError as e: | |
|
144 | if e.errno != errno.EEXIST: | |
|
145 | raise | |
|
146 | ||
|
147 | with warnings.catch_warnings(record=True) as w: | |
|
148 | ipdir = paths.get_ipython_dir() | |
|
149 | ||
|
150 | nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, ".ipython")) | |
|
151 | if sys.platform != 'darwin': | |
|
152 | nt.assert_equal(len(w), 1) | |
|
153 | nt.assert_in('Ignoring', str(w[0])) | |
|
154 | ||
|
155 | @with_environment | |
|
156 | def test_get_ipython_dir_5(): | |
|
157 | """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist.""" | |
|
158 | with patch_get_home_dir(HOME_TEST_DIR): | |
|
159 | os.name = "posix" | |
|
160 | env.pop('IPYTHON_DIR', None) | |
|
161 | env.pop('IPYTHONDIR', None) | |
|
162 | env['XDG_CONFIG_HOME'] = XDG_TEST_DIR | |
|
163 | try: | |
|
164 | os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython')) | |
|
165 | except OSError as e: | |
|
166 | if e.errno != errno.ENOENT: | |
|
167 | raise | |
|
168 | ipdir = paths.get_ipython_dir() | |
|
169 | nt.assert_equal(ipdir, IP_TEST_DIR) | |
|
170 | ||
|
171 | @with_environment | |
|
172 | def test_get_ipython_dir_6(): | |
|
173 | """test_get_ipython_dir_6, use home over XDG if defined and neither exist.""" | |
|
174 | xdg = os.path.join(HOME_TEST_DIR, 'somexdg') | |
|
175 | os.mkdir(xdg) | |
|
176 | shutil.rmtree(os.path.join(HOME_TEST_DIR, '.ipython')) | |
|
177 | with patch_get_home_dir(HOME_TEST_DIR): | |
|
178 | orig_get_xdg_dir = paths.get_xdg_dir | |
|
179 | paths.get_xdg_dir = lambda : xdg | |
|
180 | try: | |
|
181 | os.name = "posix" | |
|
182 | env.pop('IPYTHON_DIR', None) | |
|
183 | env.pop('IPYTHONDIR', None) | |
|
184 | env.pop('XDG_CONFIG_HOME', None) | |
|
185 | with warnings.catch_warnings(record=True) as w: | |
|
186 | ipdir = paths.get_ipython_dir() | |
|
187 | ||
|
188 | nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, '.ipython')) | |
|
189 | nt.assert_equal(len(w), 0) | |
|
190 | finally: | |
|
191 | paths.get_xdg_dir = orig_get_xdg_dir | |
|
192 | ||
|
193 | @with_environment | |
|
194 | def test_get_ipython_dir_7(): | |
|
195 | """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR""" | |
|
196 | paths._writable_dir = lambda path: True | |
|
197 | home_dir = os.path.normpath(os.path.expanduser('~')) | |
|
198 | env['IPYTHONDIR'] = os.path.join('~', 'somewhere') | |
|
199 | ipdir = paths.get_ipython_dir() | |
|
200 | nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere')) | |
|
201 | ||
|
202 | @skip_win32 | |
|
203 | @with_environment | |
|
204 | def test_get_ipython_dir_8(): | |
|
205 | """test_get_ipython_dir_8, test / home directory""" | |
|
206 | old = paths._writable_dir, paths.get_xdg_dir | |
|
207 | try: | |
|
208 | paths._writable_dir = lambda path: bool(path) | |
|
209 | paths.get_xdg_dir = lambda: None | |
|
210 | env.pop('IPYTHON_DIR', None) | |
|
211 | env.pop('IPYTHONDIR', None) | |
|
212 | env['HOME'] = '/' | |
|
213 | nt.assert_equal(paths.get_ipython_dir(), '/.ipython') | |
|
214 | finally: | |
|
215 | paths._writable_dir, paths.get_xdg_dir = old | |
|
216 | ||
|
217 | ||
|
218 | @with_environment | |
|
219 | def test_get_ipython_cache_dir(): | |
|
220 | os.environ["HOME"] = HOME_TEST_DIR | |
|
221 | if os.name == 'posix' and sys.platform != 'darwin': | |
|
222 | # test default | |
|
223 | os.makedirs(os.path.join(HOME_TEST_DIR, ".cache")) | |
|
224 | os.environ.pop("XDG_CACHE_HOME", None) | |
|
225 | ipdir = paths.get_ipython_cache_dir() | |
|
226 | nt.assert_equal(os.path.join(HOME_TEST_DIR, ".cache", "ipython"), | |
|
227 | ipdir) | |
|
228 | nt.assert_true(os.path.isdir(ipdir)) | |
|
229 | ||
|
230 | # test env override | |
|
231 | os.environ["XDG_CACHE_HOME"] = XDG_CACHE_DIR | |
|
232 | ipdir = paths.get_ipython_cache_dir() | |
|
233 | nt.assert_true(os.path.isdir(ipdir)) | |
|
234 | nt.assert_equal(ipdir, os.path.join(XDG_CACHE_DIR, "ipython")) | |
|
235 | else: | |
|
236 | nt.assert_equal(paths.get_ipython_cache_dir(), | |
|
237 | paths.get_ipython_dir()) | |
|
238 | ||
|
239 | def test_get_ipython_package_dir(): | |
|
240 | ipdir = paths.get_ipython_package_dir() | |
|
241 | nt.assert_true(os.path.isdir(ipdir)) | |
|
242 | ||
|
243 | ||
|
244 | def test_get_ipython_module_path(): | |
|
245 | ipapp_path = paths.get_ipython_module_path('IPython.terminal.ipapp') | |
|
246 | nt.assert_true(os.path.isfile(ipapp_path)) |
@@ -60,12 +60,8 b' except NameError: # Python 3' | |||
|
60 | 60 | # Globals |
|
61 | 61 | #----------------------------------------------------------------------------- |
|
62 | 62 | env = os.environ |
|
63 | TEST_FILE_PATH = split(abspath(__file__))[0] | |
|
64 | 63 | TMP_TEST_DIR = tempfile.mkdtemp() |
|
65 | 64 | HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir") |
|
66 | XDG_TEST_DIR = join(HOME_TEST_DIR, "xdg_test_dir") | |
|
67 | XDG_CACHE_DIR = join(HOME_TEST_DIR, "xdg_cache_dir") | |
|
68 | IP_TEST_DIR = join(HOME_TEST_DIR,'.ipython') | |
|
69 | 65 | # |
|
70 | 66 | # Setup/teardown functions/decorators |
|
71 | 67 | # |
@@ -77,9 +73,7 b' def setup():' | |||
|
77 | 73 | """ |
|
78 | 74 | # Do not mask exceptions here. In particular, catching WindowsError is a |
|
79 | 75 | # problem because that exception is only defined on Windows... |
|
80 |
os.makedirs( |
|
|
81 | os.makedirs(os.path.join(XDG_TEST_DIR, 'ipython')) | |
|
82 | os.makedirs(os.path.join(XDG_CACHE_DIR, 'ipython')) | |
|
76 | os.makedirs(os.path.join(HOME_TEST_DIR, 'ipython')) | |
|
83 | 77 | |
|
84 | 78 | |
|
85 | 79 | def teardown(): |
@@ -120,15 +114,6 b' def teardown_environment():' | |||
|
120 | 114 | # Build decorator that uses the setup_environment/setup_environment |
|
121 | 115 | with_environment = with_setup(setup_environment, teardown_environment) |
|
122 | 116 | |
|
123 | @contextmanager | |
|
124 | def patch_get_home_dir(dirpath): | |
|
125 | orig_get_home_dir = path.get_home_dir | |
|
126 | path.get_home_dir = lambda : dirpath | |
|
127 | try: | |
|
128 | yield | |
|
129 | finally: | |
|
130 | path.get_home_dir = orig_get_home_dir | |
|
131 | ||
|
132 | 117 | @skip_if_not_win32 |
|
133 | 118 | @with_environment |
|
134 | 119 | def test_get_home_dir_1(): |
@@ -205,135 +190,6 b' def test_get_home_dir_8():' | |||
|
205 | 190 | home_dir = path.get_home_dir() |
|
206 | 191 | nt.assert_equal(home_dir, abspath(HOME_TEST_DIR)) |
|
207 | 192 | |
|
208 | ||
|
209 | @with_environment | |
|
210 | def test_get_ipython_dir_1(): | |
|
211 | """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions.""" | |
|
212 | env_ipdir = os.path.join("someplace", ".ipython") | |
|
213 | path._writable_dir = lambda path: True | |
|
214 | env['IPYTHONDIR'] = env_ipdir | |
|
215 | ipdir = path.get_ipython_dir() | |
|
216 | nt.assert_equal(ipdir, env_ipdir) | |
|
217 | ||
|
218 | ||
|
219 | @with_environment | |
|
220 | def test_get_ipython_dir_2(): | |
|
221 | """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions.""" | |
|
222 | with patch_get_home_dir('someplace'): | |
|
223 | path.get_xdg_dir = lambda : None | |
|
224 | path._writable_dir = lambda path: True | |
|
225 | os.name = "posix" | |
|
226 | env.pop('IPYTHON_DIR', None) | |
|
227 | env.pop('IPYTHONDIR', None) | |
|
228 | env.pop('XDG_CONFIG_HOME', None) | |
|
229 | ipdir = path.get_ipython_dir() | |
|
230 | nt.assert_equal(ipdir, os.path.join("someplace", ".ipython")) | |
|
231 | ||
|
232 | @with_environment | |
|
233 | def test_get_ipython_dir_3(): | |
|
234 | """test_get_ipython_dir_3, move XDG if defined, and .ipython doesn't exist.""" | |
|
235 | tmphome = TemporaryDirectory() | |
|
236 | try: | |
|
237 | with patch_get_home_dir(tmphome.name): | |
|
238 | os.name = "posix" | |
|
239 | env.pop('IPYTHON_DIR', None) | |
|
240 | env.pop('IPYTHONDIR', None) | |
|
241 | env['XDG_CONFIG_HOME'] = XDG_TEST_DIR | |
|
242 | ||
|
243 | with warnings.catch_warnings(record=True) as w: | |
|
244 | ipdir = path.get_ipython_dir() | |
|
245 | ||
|
246 | nt.assert_equal(ipdir, os.path.join(tmphome.name, ".ipython")) | |
|
247 | if sys.platform != 'darwin': | |
|
248 | nt.assert_equal(len(w), 1) | |
|
249 | nt.assert_in('Moving', str(w[0])) | |
|
250 | finally: | |
|
251 | tmphome.cleanup() | |
|
252 | ||
|
253 | @with_environment | |
|
254 | def test_get_ipython_dir_4(): | |
|
255 | """test_get_ipython_dir_4, warn if XDG and home both exist.""" | |
|
256 | with patch_get_home_dir(HOME_TEST_DIR): | |
|
257 | os.name = "posix" | |
|
258 | env.pop('IPYTHON_DIR', None) | |
|
259 | env.pop('IPYTHONDIR', None) | |
|
260 | env['XDG_CONFIG_HOME'] = XDG_TEST_DIR | |
|
261 | try: | |
|
262 | os.mkdir(os.path.join(XDG_TEST_DIR, 'ipython')) | |
|
263 | except OSError as e: | |
|
264 | if e.errno != errno.EEXIST: | |
|
265 | raise | |
|
266 | ||
|
267 | with warnings.catch_warnings(record=True) as w: | |
|
268 | ipdir = path.get_ipython_dir() | |
|
269 | ||
|
270 | nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, ".ipython")) | |
|
271 | if sys.platform != 'darwin': | |
|
272 | nt.assert_equal(len(w), 1) | |
|
273 | nt.assert_in('Ignoring', str(w[0])) | |
|
274 | ||
|
275 | @with_environment | |
|
276 | def test_get_ipython_dir_5(): | |
|
277 | """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist.""" | |
|
278 | with patch_get_home_dir(HOME_TEST_DIR): | |
|
279 | os.name = "posix" | |
|
280 | env.pop('IPYTHON_DIR', None) | |
|
281 | env.pop('IPYTHONDIR', None) | |
|
282 | env['XDG_CONFIG_HOME'] = XDG_TEST_DIR | |
|
283 | try: | |
|
284 | os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython')) | |
|
285 | except OSError as e: | |
|
286 | if e.errno != errno.ENOENT: | |
|
287 | raise | |
|
288 | ipdir = path.get_ipython_dir() | |
|
289 | nt.assert_equal(ipdir, IP_TEST_DIR) | |
|
290 | ||
|
291 | @with_environment | |
|
292 | def test_get_ipython_dir_6(): | |
|
293 | """test_get_ipython_dir_6, use home over XDG if defined and neither exist.""" | |
|
294 | xdg = os.path.join(HOME_TEST_DIR, 'somexdg') | |
|
295 | os.mkdir(xdg) | |
|
296 | shutil.rmtree(os.path.join(HOME_TEST_DIR, '.ipython')) | |
|
297 | with patch_get_home_dir(HOME_TEST_DIR): | |
|
298 | orig_get_xdg_dir = path.get_xdg_dir | |
|
299 | path.get_xdg_dir = lambda : xdg | |
|
300 | try: | |
|
301 | os.name = "posix" | |
|
302 | env.pop('IPYTHON_DIR', None) | |
|
303 | env.pop('IPYTHONDIR', None) | |
|
304 | env.pop('XDG_CONFIG_HOME', None) | |
|
305 | with warnings.catch_warnings(record=True) as w: | |
|
306 | ipdir = path.get_ipython_dir() | |
|
307 | ||
|
308 | nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, '.ipython')) | |
|
309 | nt.assert_equal(len(w), 0) | |
|
310 | finally: | |
|
311 | path.get_xdg_dir = orig_get_xdg_dir | |
|
312 | ||
|
313 | @with_environment | |
|
314 | def test_get_ipython_dir_7(): | |
|
315 | """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR""" | |
|
316 | path._writable_dir = lambda path: True | |
|
317 | home_dir = os.path.normpath(os.path.expanduser('~')) | |
|
318 | env['IPYTHONDIR'] = os.path.join('~', 'somewhere') | |
|
319 | ipdir = path.get_ipython_dir() | |
|
320 | nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere')) | |
|
321 | ||
|
322 | @skip_win32 | |
|
323 | @with_environment | |
|
324 | def test_get_ipython_dir_8(): | |
|
325 | """test_get_ipython_dir_8, test / home directory""" | |
|
326 | old = path._writable_dir, path.get_xdg_dir | |
|
327 | try: | |
|
328 | path._writable_dir = lambda path: bool(path) | |
|
329 | path.get_xdg_dir = lambda: None | |
|
330 | env.pop('IPYTHON_DIR', None) | |
|
331 | env.pop('IPYTHONDIR', None) | |
|
332 | env['HOME'] = '/' | |
|
333 | nt.assert_equal(path.get_ipython_dir(), '/.ipython') | |
|
334 | finally: | |
|
335 | path._writable_dir, path.get_xdg_dir = old | |
|
336 | ||
|
337 | 193 | @with_environment |
|
338 | 194 | def test_get_xdg_dir_0(): |
|
339 | 195 | """test_get_xdg_dir_0, check xdg_dir""" |
@@ -401,36 +257,6 b' def test_filefind():' | |||
|
401 | 257 | t = path.filefind(f.name, alt_dirs) |
|
402 | 258 | # print 'found:',t |
|
403 | 259 | |
|
404 | @with_environment | |
|
405 | def test_get_ipython_cache_dir(): | |
|
406 | os.environ["HOME"] = HOME_TEST_DIR | |
|
407 | if os.name == 'posix' and sys.platform != 'darwin': | |
|
408 | # test default | |
|
409 | os.makedirs(os.path.join(HOME_TEST_DIR, ".cache")) | |
|
410 | os.environ.pop("XDG_CACHE_HOME", None) | |
|
411 | ipdir = path.get_ipython_cache_dir() | |
|
412 | nt.assert_equal(os.path.join(HOME_TEST_DIR, ".cache", "ipython"), | |
|
413 | ipdir) | |
|
414 | nt.assert_true(os.path.isdir(ipdir)) | |
|
415 | ||
|
416 | # test env override | |
|
417 | os.environ["XDG_CACHE_HOME"] = XDG_CACHE_DIR | |
|
418 | ipdir = path.get_ipython_cache_dir() | |
|
419 | nt.assert_true(os.path.isdir(ipdir)) | |
|
420 | nt.assert_equal(ipdir, os.path.join(XDG_CACHE_DIR, "ipython")) | |
|
421 | else: | |
|
422 | nt.assert_equal(path.get_ipython_cache_dir(), | |
|
423 | path.get_ipython_dir()) | |
|
424 | ||
|
425 | def test_get_ipython_package_dir(): | |
|
426 | ipdir = path.get_ipython_package_dir() | |
|
427 | nt.assert_true(os.path.isdir(ipdir)) | |
|
428 | ||
|
429 | ||
|
430 | def test_get_ipython_module_path(): | |
|
431 | ipapp_path = path.get_ipython_module_path('IPython.terminal.ipapp') | |
|
432 | nt.assert_true(os.path.isfile(ipapp_path)) | |
|
433 | ||
|
434 | 260 | |
|
435 | 261 | @dec.skip_if_not_win32 |
|
436 | 262 | def test_get_long_path_name_win32(): |
General Comments 0
You need to be logged in to leave comments.
Login now