Show More
@@ -0,0 +1,16 b'' | |||
|
1 | # See https://pre-commit.com for more information | |
|
2 | # See https://pre-commit.com/hooks.html for more hooks | |
|
3 | repos: | |
|
4 | - repo: https://github.com/pre-commit/pre-commit-hooks | |
|
5 | rev: v3.2.0 | |
|
6 | hooks: | |
|
7 | - id: trailing-whitespace | |
|
8 | - id: end-of-file-fixer | |
|
9 | - id: check-yaml | |
|
10 | - id: check-added-large-files | |
|
11 | ||
|
12 | - repo: https://github.com/akaihola/darker | |
|
13 | rev: 1.3.1 | |
|
14 | hooks: | |
|
15 | - id: darker | |
|
16 |
@@ -4,8 +4,6 b'' | |||
|
4 | 4 | import os |
|
5 | 5 | import tempfile |
|
6 | 6 | |
|
7 | import nose.tools as nt | |
|
8 | ||
|
9 | 7 | from traitlets import Unicode |
|
10 | 8 | |
|
11 | 9 | from IPython.core.application import BaseIPythonApplication |
@@ -65,9 +63,8 b' def test_cli_priority():' | |||
|
65 | 63 | f.write("c.TestApp.test = 'config file'") |
|
66 | 64 | |
|
67 | 65 | app = TestApp() |
|
68 |
app.initialize([ |
|
|
69 |
|
|
|
66 | app.initialize(["--profile-dir", td]) | |
|
67 | assert app.test == "config file" | |
|
70 | 68 | app = TestApp() |
|
71 |
app.initialize([ |
|
|
72 |
|
|
|
73 | ||
|
69 | app.initialize(["--profile-dir", td, "--TestApp.test=cli"]) | |
|
70 | assert app.test == "cli" |
@@ -4,7 +4,6 b' Test for async helpers.' | |||
|
4 | 4 | Should only trigger on python 3.5+ or will have syntax errors. |
|
5 | 5 | """ |
|
6 | 6 | from itertools import chain, repeat |
|
7 | import nose.tools as nt | |
|
8 | 7 | from textwrap import dedent, indent |
|
9 | 8 | from unittest import TestCase |
|
10 | 9 | from IPython.testing.decorators import skip_without |
@@ -24,10 +23,10 b' from IPython.core.async_helpers import _should_be_async' | |||
|
24 | 23 | |
|
25 | 24 | class AsyncTest(TestCase): |
|
26 | 25 | def test_should_be_async(self): |
|
27 |
|
|
|
28 |
|
|
|
29 |
|
|
|
30 |
|
|
|
26 | self.assertFalse(_should_be_async("False")) | |
|
27 | self.assertTrue(_should_be_async("await bar()")) | |
|
28 | self.assertTrue(_should_be_async("x = await bar()")) | |
|
29 | self.assertFalse( | |
|
31 | 30 | _should_be_async( |
|
32 | 31 | dedent( |
|
33 | 32 | """ |
@@ -298,7 +297,7 b' class AsyncTest(TestCase):' | |||
|
298 | 297 | import asyncio |
|
299 | 298 | await asyncio.sleep(0) |
|
300 | 299 | """) |
|
301 |
with |
|
|
300 | with self.assertRaises(TypeError): | |
|
302 | 301 | res.raise_error() |
|
303 | 302 | |
|
304 | 303 | @skip_without('trio') |
@@ -308,7 +307,7 b' class AsyncTest(TestCase):' | |||
|
308 | 307 | import trio |
|
309 | 308 | await trio.sleep(0) |
|
310 | 309 | """) |
|
311 |
with |
|
|
310 | with self.assertRaises(RuntimeError): | |
|
312 | 311 | res.raise_error() |
|
313 | 312 | |
|
314 | 313 |
@@ -11,8 +11,6 b' import unittest' | |||
|
11 | 11 | |
|
12 | 12 | from contextlib import contextmanager |
|
13 | 13 | |
|
14 | import nose.tools as nt | |
|
15 | ||
|
16 | 14 | from traitlets.config.loader import Config |
|
17 | 15 | from IPython import get_ipython |
|
18 | 16 | from IPython.core import completer |
@@ -27,7 +25,6 b' from IPython.core.completer import (' | |||
|
27 | 25 | match_dict_keys, |
|
28 | 26 | _deduplicate_completions, |
|
29 | 27 | ) |
|
30 | from nose.tools import assert_in, assert_not_in | |
|
31 | 28 | |
|
32 | 29 | # ----------------------------------------------------------------------------- |
|
33 | 30 | # Test functions |
@@ -150,7 +147,7 b' def test_protect_filename():' | |||
|
150 | 147 | # run the actual tests |
|
151 | 148 | for s1, s2 in pairs: |
|
152 | 149 | s1p = completer.protect_filename(s1) |
|
153 |
|
|
|
150 | assert s1p == s2 | |
|
154 | 151 | |
|
155 | 152 | |
|
156 | 153 | def check_line_split(splitter, test_specs): |
@@ -158,7 +155,7 b' def check_line_split(splitter, test_specs):' | |||
|
158 | 155 | cursor_pos = len(part1) |
|
159 | 156 | line = part1 + part2 |
|
160 | 157 | out = splitter.split_line(line, cursor_pos) |
|
161 |
|
|
|
158 | assert out == split | |
|
162 | 159 | |
|
163 | 160 | |
|
164 | 161 | def test_line_split(): |
@@ -267,8 +264,8 b' class TestCompleter(unittest.TestCase):' | |||
|
267 | 264 | # should be thrown and the return value should be a pair of text, list |
|
268 | 265 | # values. |
|
269 | 266 | text, matches = ip.complete(t) |
|
270 |
|
|
|
271 |
|
|
|
267 | self.assertIsInstance(text, str) | |
|
268 | self.assertIsInstance(matches, list) | |
|
272 | 269 | |
|
273 | 270 | def test_latex_completions(self): |
|
274 | 271 | from IPython.core.latex_symbols import latex_symbols |
@@ -279,16 +276,16 b' class TestCompleter(unittest.TestCase):' | |||
|
279 | 276 | keys = random.sample(latex_symbols.keys(), 10) |
|
280 | 277 | for k in keys: |
|
281 | 278 | text, matches = ip.complete(k) |
|
282 |
|
|
|
283 |
|
|
|
279 | self.assertEqual(text, k) | |
|
280 | self.assertEqual(matches, [latex_symbols[k]]) | |
|
284 | 281 | # Test a more complex line |
|
285 | 282 | text, matches = ip.complete("print(\\alpha") |
|
286 |
|
|
|
287 |
|
|
|
283 | self.assertEqual(text, "\\alpha") | |
|
284 | self.assertEqual(matches[0], latex_symbols["\\alpha"]) | |
|
288 | 285 | # Test multiple matching latex symbols |
|
289 | 286 | text, matches = ip.complete("\\al") |
|
290 |
|
|
|
291 |
|
|
|
287 | self.assertIn("\\alpha", matches) | |
|
288 | self.assertIn("\\aleph", matches) | |
|
292 | 289 | |
|
293 | 290 | def test_latex_no_results(self): |
|
294 | 291 | """ |
@@ -296,30 +293,30 b' class TestCompleter(unittest.TestCase):' | |||
|
296 | 293 | """ |
|
297 | 294 | ip = get_ipython() |
|
298 | 295 | text, matches = ip.Completer.latex_matches("\\really_i_should_match_nothing") |
|
299 |
|
|
|
300 |
|
|
|
296 | self.assertEqual(text, "") | |
|
297 | self.assertEqual(matches, ()) | |
|
301 | 298 | |
|
302 | 299 | def test_back_latex_completion(self): |
|
303 | 300 | ip = get_ipython() |
|
304 | 301 | |
|
305 | 302 | # do not return more than 1 matches for \beta, only the latex one. |
|
306 | 303 | name, matches = ip.complete("\\β") |
|
307 |
|
|
|
304 | self.assertEqual(matches, ["\\beta"]) | |
|
308 | 305 | |
|
309 | 306 | def test_back_unicode_completion(self): |
|
310 | 307 | ip = get_ipython() |
|
311 | 308 | |
|
312 | 309 | name, matches = ip.complete("\\Ⅴ") |
|
313 |
|
|
|
310 | self.assertEqual(matches, ("\\ROMAN NUMERAL FIVE",)) | |
|
314 | 311 | |
|
315 | 312 | def test_forward_unicode_completion(self): |
|
316 | 313 | ip = get_ipython() |
|
317 | 314 | |
|
318 | 315 | name, matches = ip.complete("\\ROMAN NUMERAL FIVE") |
|
319 |
|
|
|
320 |
|
|
|
316 | self.assertEqual(matches, ["Ⅴ"]) # This is not a V | |
|
317 | self.assertEqual(matches, ["\u2164"]) # same as above but explicit. | |
|
321 | 318 | |
|
322 |
@nt. |
|
|
319 | @unittest.skip("now we have a completion for \jmath") | |
|
323 | 320 | @decorators.knownfailureif( |
|
324 | 321 | sys.platform == "win32", "Fails if there is a C:\\j... path" |
|
325 | 322 | ) |
@@ -329,7 +326,7 b' class TestCompleter(unittest.TestCase):' | |||
|
329 | 326 | # single ascii letter that don't have yet completions |
|
330 | 327 | for letter in "jJ": |
|
331 | 328 | name, matches = ip.complete("\\" + letter) |
|
332 |
|
|
|
329 | self.assertEqual(matches, []) | |
|
333 | 330 | |
|
334 | 331 | class CompletionSplitterTestCase(unittest.TestCase): |
|
335 | 332 | def setUp(self): |
@@ -337,8 +334,8 b' class TestCompleter(unittest.TestCase):' | |||
|
337 | 334 | |
|
338 | 335 | def test_delim_setting(self): |
|
339 | 336 | self.sp.delims = " " |
|
340 |
|
|
|
341 |
|
|
|
337 | self.assertEqual(self.sp.delims, " ") | |
|
338 | self.assertEqual(self.sp._delim_expr, r"[\ ]") | |
|
342 | 339 | |
|
343 | 340 | def test_spaces(self): |
|
344 | 341 | """Test with only spaces as split chars.""" |
@@ -348,19 +345,19 b' class TestCompleter(unittest.TestCase):' | |||
|
348 | 345 | |
|
349 | 346 | def test_has_open_quotes1(self): |
|
350 | 347 | for s in ["'", "'''", "'hi' '"]: |
|
351 |
|
|
|
348 | self.assertEqual(completer.has_open_quotes(s), "'") | |
|
352 | 349 | |
|
353 | 350 | def test_has_open_quotes2(self): |
|
354 | 351 | for s in ['"', '"""', '"hi" "']: |
|
355 |
|
|
|
352 | self.assertEqual(completer.has_open_quotes(s), '"') | |
|
356 | 353 | |
|
357 | 354 | def test_has_open_quotes3(self): |
|
358 | 355 | for s in ["''", "''' '''", "'hi' 'ipython'"]: |
|
359 |
|
|
|
356 | self.assertFalse(completer.has_open_quotes(s)) | |
|
360 | 357 | |
|
361 | 358 | def test_has_open_quotes4(self): |
|
362 | 359 | for s in ['""', '""" """', '"hi" "ipython"']: |
|
363 |
|
|
|
360 | self.assertFalse(completer.has_open_quotes(s)) | |
|
364 | 361 | |
|
365 | 362 | @decorators.knownfailureif( |
|
366 | 363 | sys.platform == "win32", "abspath completions fail on Windows" |
@@ -376,13 +373,13 b' class TestCompleter(unittest.TestCase):' | |||
|
376 | 373 | |
|
377 | 374 | # Check simple completion |
|
378 | 375 | c = ip.complete(prefix)[1] |
|
379 |
|
|
|
376 | self.assertEqual(c, names) | |
|
380 | 377 | |
|
381 | 378 | # Now check with a function call |
|
382 | 379 | cmd = 'a = f("%s' % prefix |
|
383 | 380 | c = ip.complete(prefix, cmd)[1] |
|
384 | 381 | comp = [prefix + s for s in suffixes] |
|
385 |
|
|
|
382 | self.assertEqual(c, comp) | |
|
386 | 383 | |
|
387 | 384 | def test_local_file_completions(self): |
|
388 | 385 | ip = get_ipython() |
@@ -395,13 +392,13 b' class TestCompleter(unittest.TestCase):' | |||
|
395 | 392 | |
|
396 | 393 | # Check simple completion |
|
397 | 394 | c = ip.complete(prefix)[1] |
|
398 |
|
|
|
395 | self.assertEqual(c, names) | |
|
399 | 396 | |
|
400 | 397 | # Now check with a function call |
|
401 | 398 | cmd = 'a = f("%s' % prefix |
|
402 | 399 | c = ip.complete(prefix, cmd)[1] |
|
403 | 400 | comp = {prefix + s for s in suffixes} |
|
404 |
|
|
|
401 | self.assertTrue(comp.issubset(set(c))) | |
|
405 | 402 | |
|
406 | 403 | def test_quoted_file_completions(self): |
|
407 | 404 | ip = get_ipython() |
@@ -417,21 +414,21 b' class TestCompleter(unittest.TestCase):' | |||
|
417 | 414 | c = ip.Completer._complete( |
|
418 | 415 | cursor_line=0, cursor_pos=len(text), full_text=text |
|
419 | 416 | )[1] |
|
420 |
|
|
|
417 | self.assertEqual(c, [escaped]) | |
|
421 | 418 | |
|
422 | 419 | # Double quote requires no escape |
|
423 | 420 | text = 'open("foo' |
|
424 | 421 | c = ip.Completer._complete( |
|
425 | 422 | cursor_line=0, cursor_pos=len(text), full_text=text |
|
426 | 423 | )[1] |
|
427 |
|
|
|
424 | self.assertEqual(c, [name]) | |
|
428 | 425 | |
|
429 | 426 | # No quote requires an escape |
|
430 | 427 | text = "%ls foo" |
|
431 | 428 | c = ip.Completer._complete( |
|
432 | 429 | cursor_line=0, cursor_pos=len(text), full_text=text |
|
433 | 430 | )[1] |
|
434 |
|
|
|
431 | self.assertEqual(c, [escaped]) | |
|
435 | 432 | |
|
436 | 433 | def test_all_completions_dups(self): |
|
437 | 434 | """ |
@@ -537,18 +534,18 b' class TestCompleter(unittest.TestCase):' | |||
|
537 | 534 | ip = get_ipython() |
|
538 | 535 | ip.ex("a=list(range(5))") |
|
539 | 536 | _, c = ip.complete(".", line="a[0].") |
|
540 |
|
|
|
537 | self.assertFalse(".real" in c, "Shouldn't have completed on a[0]: %s" % c) | |
|
541 | 538 | |
|
542 | 539 | def _(line, cursor_pos, expect, message, completion): |
|
543 | 540 | with greedy_completion(), provisionalcompleter(): |
|
544 | 541 | ip.Completer.use_jedi = False |
|
545 | 542 | _, c = ip.complete(".", line=line, cursor_pos=cursor_pos) |
|
546 |
|
|
|
543 | self.assertIn(expect, c, message % c) | |
|
547 | 544 | |
|
548 | 545 | ip.Completer.use_jedi = True |
|
549 | 546 | with provisionalcompleter(): |
|
550 | 547 | completions = ip.Completer.completions(line, cursor_pos) |
|
551 |
|
|
|
548 | self.assertIn(completion, completions) | |
|
552 | 549 | |
|
553 | 550 | with provisionalcompleter(): |
|
554 | 551 | yield _, "a[0].", 5, "a[0].real", "Should have completed on a[0].: %s", Completion( |
@@ -575,13 +572,13 b' class TestCompleter(unittest.TestCase):' | |||
|
575 | 572 | with provisionalcompleter(): |
|
576 | 573 | c.use_jedi = False |
|
577 | 574 | s, matches = c.complete("ip.") |
|
578 |
|
|
|
579 |
|
|
|
575 | self.assertIn("ip.__str__", matches) | |
|
576 | self.assertIn("ip._hidden_attr", matches) | |
|
580 | 577 | |
|
581 | 578 | # c.use_jedi = True |
|
582 | 579 | # completions = set(c.completions('ip.', 3)) |
|
583 |
# |
|
|
584 |
# |
|
|
580 | # self.assertIn(Completion(3, 3, '__str__'), completions) | |
|
581 | # self.assertIn(Completion(3,3, "_hidden_attr"), completions) | |
|
585 | 582 | |
|
586 | 583 | cfg = Config() |
|
587 | 584 | cfg.IPCompleter.omit__names = 1 |
@@ -589,13 +586,13 b' class TestCompleter(unittest.TestCase):' | |||
|
589 | 586 | with provisionalcompleter(): |
|
590 | 587 | c.use_jedi = False |
|
591 | 588 | s, matches = c.complete("ip.") |
|
592 |
|
|
|
593 |
# |
|
|
589 | self.assertNotIn("ip.__str__", matches) | |
|
590 | # self.assertIn('ip._hidden_attr', matches) | |
|
594 | 591 | |
|
595 | 592 | # c.use_jedi = True |
|
596 | 593 | # completions = set(c.completions('ip.', 3)) |
|
597 |
# |
|
|
598 |
# |
|
|
594 | # self.assertNotIn(Completion(3,3,'__str__'), completions) | |
|
595 | # self.assertIn(Completion(3,3, "_hidden_attr"), completions) | |
|
599 | 596 | |
|
600 | 597 | cfg = Config() |
|
601 | 598 | cfg.IPCompleter.omit__names = 2 |
@@ -603,22 +600,22 b' class TestCompleter(unittest.TestCase):' | |||
|
603 | 600 | with provisionalcompleter(): |
|
604 | 601 | c.use_jedi = False |
|
605 | 602 | s, matches = c.complete("ip.") |
|
606 |
|
|
|
607 |
|
|
|
603 | self.assertNotIn("ip.__str__", matches) | |
|
604 | self.assertNotIn("ip._hidden_attr", matches) | |
|
608 | 605 | |
|
609 | 606 | # c.use_jedi = True |
|
610 | 607 | # completions = set(c.completions('ip.', 3)) |
|
611 |
# |
|
|
612 |
# |
|
|
608 | # self.assertNotIn(Completion(3,3,'__str__'), completions) | |
|
609 | # self.assertNotIn(Completion(3,3, "_hidden_attr"), completions) | |
|
613 | 610 | |
|
614 | 611 | with provisionalcompleter(): |
|
615 | 612 | c.use_jedi = False |
|
616 | 613 | s, matches = c.complete("ip._x.") |
|
617 |
|
|
|
614 | self.assertIn("ip._x.keys", matches) | |
|
618 | 615 | |
|
619 | 616 | # c.use_jedi = True |
|
620 | 617 | # completions = set(c.completions('ip._x.', 6)) |
|
621 |
# |
|
|
618 | # self.assertIn(Completion(6,6, "keys"), completions) | |
|
622 | 619 | |
|
623 | 620 | del ip._hidden_attr |
|
624 | 621 | del ip._x |
@@ -636,21 +633,21 b' class TestCompleter(unittest.TestCase):' | |||
|
636 | 633 | cfg.IPCompleter.limit_to__all__ = False |
|
637 | 634 | c.update_config(cfg) |
|
638 | 635 | s, matches = c.complete("d.") |
|
639 |
|
|
|
636 | self.assertIn("d.x", matches) | |
|
640 | 637 | |
|
641 | 638 | def test_get__all__entries_ok(self): |
|
642 | 639 | class A: |
|
643 | 640 | __all__ = ["x", 1] |
|
644 | 641 | |
|
645 | 642 | words = completer.get__all__entries(A()) |
|
646 |
|
|
|
643 | self.assertEqual(words, ["x"]) | |
|
647 | 644 | |
|
648 | 645 | def test_get__all__entries_no__all__ok(self): |
|
649 | 646 | class A: |
|
650 | 647 | pass |
|
651 | 648 | |
|
652 | 649 | words = completer.get__all__entries(A()) |
|
653 |
|
|
|
650 | self.assertEqual(words, []) | |
|
654 | 651 | |
|
655 | 652 | def test_func_kw_completions(self): |
|
656 | 653 | ip = get_ipython() |
@@ -658,39 +655,39 b' class TestCompleter(unittest.TestCase):' | |||
|
658 | 655 | c.use_jedi = False |
|
659 | 656 | ip.ex("def myfunc(a=1,b=2): return a+b") |
|
660 | 657 | s, matches = c.complete(None, "myfunc(1,b") |
|
661 |
|
|
|
658 | self.assertIn("b=", matches) | |
|
662 | 659 | # Simulate completing with cursor right after b (pos==10): |
|
663 | 660 | s, matches = c.complete(None, "myfunc(1,b)", 10) |
|
664 |
|
|
|
661 | self.assertIn("b=", matches) | |
|
665 | 662 | s, matches = c.complete(None, 'myfunc(a="escaped\\")string",b') |
|
666 |
|
|
|
663 | self.assertIn("b=", matches) | |
|
667 | 664 | # builtin function |
|
668 | 665 | s, matches = c.complete(None, "min(k, k") |
|
669 |
|
|
|
666 | self.assertIn("key=", matches) | |
|
670 | 667 | |
|
671 | 668 | def test_default_arguments_from_docstring(self): |
|
672 | 669 | ip = get_ipython() |
|
673 | 670 | c = ip.Completer |
|
674 | 671 | kwd = c._default_arguments_from_docstring("min(iterable[, key=func]) -> value") |
|
675 |
|
|
|
672 | self.assertEqual(kwd, ["key"]) | |
|
676 | 673 | # with cython type etc |
|
677 | 674 | kwd = c._default_arguments_from_docstring( |
|
678 | 675 | "Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n" |
|
679 | 676 | ) |
|
680 |
|
|
|
677 | self.assertEqual(kwd, ["ncall", "resume", "nsplit"]) | |
|
681 | 678 | # white spaces |
|
682 | 679 | kwd = c._default_arguments_from_docstring( |
|
683 | 680 | "\n Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n" |
|
684 | 681 | ) |
|
685 |
|
|
|
682 | self.assertEqual(kwd, ["ncall", "resume", "nsplit"]) | |
|
686 | 683 | |
|
687 | 684 | def test_line_magics(self): |
|
688 | 685 | ip = get_ipython() |
|
689 | 686 | c = ip.Completer |
|
690 | 687 | s, matches = c.complete(None, "lsmag") |
|
691 |
|
|
|
688 | self.assertIn("%lsmagic", matches) | |
|
692 | 689 | s, matches = c.complete(None, "%lsmag") |
|
693 |
|
|
|
690 | self.assertIn("%lsmagic", matches) | |
|
694 | 691 | |
|
695 | 692 | def test_cell_magics(self): |
|
696 | 693 | from IPython.core.magic import register_cell_magic |
@@ -703,9 +700,9 b' class TestCompleter(unittest.TestCase):' | |||
|
703 | 700 | c = ip.Completer |
|
704 | 701 | |
|
705 | 702 | s, matches = c.complete(None, "_foo_ce") |
|
706 |
|
|
|
703 | self.assertIn("%%_foo_cellm", matches) | |
|
707 | 704 | s, matches = c.complete(None, "%%_foo_ce") |
|
708 |
|
|
|
705 | self.assertIn("%%_foo_cellm", matches) | |
|
709 | 706 | |
|
710 | 707 | def test_line_cell_magics(self): |
|
711 | 708 | from IPython.core.magic import register_line_cell_magic |
@@ -722,14 +719,14 b' class TestCompleter(unittest.TestCase):' | |||
|
722 | 719 | # and this will show a difference if the same name is both a line and cell |
|
723 | 720 | # magic. |
|
724 | 721 | s, matches = c.complete(None, "_bar_ce") |
|
725 |
|
|
|
726 |
|
|
|
722 | self.assertIn("%_bar_cellm", matches) | |
|
723 | self.assertIn("%%_bar_cellm", matches) | |
|
727 | 724 | s, matches = c.complete(None, "%_bar_ce") |
|
728 |
|
|
|
729 |
|
|
|
725 | self.assertIn("%_bar_cellm", matches) | |
|
726 | self.assertIn("%%_bar_cellm", matches) | |
|
730 | 727 | s, matches = c.complete(None, "%%_bar_ce") |
|
731 |
|
|
|
732 |
|
|
|
728 | self.assertNotIn("%_bar_cellm", matches) | |
|
729 | self.assertIn("%%_bar_cellm", matches) | |
|
733 | 730 | |
|
734 | 731 | def test_magic_completion_order(self): |
|
735 | 732 | ip = get_ipython() |
@@ -737,7 +734,7 b' class TestCompleter(unittest.TestCase):' | |||
|
737 | 734 | |
|
738 | 735 | # Test ordering of line and cell magics. |
|
739 | 736 | text, matches = c.complete("timeit") |
|
740 |
|
|
|
737 | self.assertEqual(matches, ["%timeit", "%%timeit"]) | |
|
741 | 738 | |
|
742 | 739 | def test_magic_completion_shadowing(self): |
|
743 | 740 | ip = get_ipython() |
@@ -746,18 +743,18 b' class TestCompleter(unittest.TestCase):' | |||
|
746 | 743 | |
|
747 | 744 | # Before importing matplotlib, %matplotlib magic should be the only option. |
|
748 | 745 | text, matches = c.complete("mat") |
|
749 |
|
|
|
746 | self.assertEqual(matches, ["%matplotlib"]) | |
|
750 | 747 | |
|
751 | 748 | # The newly introduced name should shadow the magic. |
|
752 | 749 | ip.run_cell("matplotlib = 1") |
|
753 | 750 | text, matches = c.complete("mat") |
|
754 |
|
|
|
751 | self.assertEqual(matches, ["matplotlib"]) | |
|
755 | 752 | |
|
756 | 753 | # After removing matplotlib from namespace, the magic should again be |
|
757 | 754 | # the only option. |
|
758 | 755 | del ip.user_ns["matplotlib"] |
|
759 | 756 | text, matches = c.complete("mat") |
|
760 |
|
|
|
757 | self.assertEqual(matches, ["%matplotlib"]) | |
|
761 | 758 | |
|
762 | 759 | def test_magic_completion_shadowing_explicit(self): |
|
763 | 760 | """ |
@@ -769,62 +766,62 b' class TestCompleter(unittest.TestCase):' | |||
|
769 | 766 | |
|
770 | 767 | # Before importing matplotlib, %matplotlib magic should be the only option. |
|
771 | 768 | text, matches = c.complete("%mat") |
|
772 |
|
|
|
769 | self.assertEqual(matches, ["%matplotlib"]) | |
|
773 | 770 | |
|
774 | 771 | ip.run_cell("matplotlib = 1") |
|
775 | 772 | |
|
776 | 773 | # After removing matplotlib from namespace, the magic should still be |
|
777 | 774 | # the only option. |
|
778 | 775 | text, matches = c.complete("%mat") |
|
779 |
|
|
|
776 | self.assertEqual(matches, ["%matplotlib"]) | |
|
780 | 777 | |
|
781 | 778 | def test_magic_config(self): |
|
782 | 779 | ip = get_ipython() |
|
783 | 780 | c = ip.Completer |
|
784 | 781 | |
|
785 | 782 | s, matches = c.complete(None, "conf") |
|
786 |
|
|
|
783 | self.assertIn("%config", matches) | |
|
787 | 784 | s, matches = c.complete(None, "conf") |
|
788 |
|
|
|
785 | self.assertNotIn("AliasManager", matches) | |
|
789 | 786 | s, matches = c.complete(None, "config ") |
|
790 |
|
|
|
787 | self.assertIn("AliasManager", matches) | |
|
791 | 788 | s, matches = c.complete(None, "%config ") |
|
792 |
|
|
|
789 | self.assertIn("AliasManager", matches) | |
|
793 | 790 | s, matches = c.complete(None, "config Ali") |
|
794 |
|
|
|
791 | self.assertListEqual(["AliasManager"], matches) | |
|
795 | 792 | s, matches = c.complete(None, "%config Ali") |
|
796 |
|
|
|
793 | self.assertListEqual(["AliasManager"], matches) | |
|
797 | 794 | s, matches = c.complete(None, "config AliasManager") |
|
798 |
|
|
|
795 | self.assertListEqual(["AliasManager"], matches) | |
|
799 | 796 | s, matches = c.complete(None, "%config AliasManager") |
|
800 |
|
|
|
797 | self.assertListEqual(["AliasManager"], matches) | |
|
801 | 798 | s, matches = c.complete(None, "config AliasManager.") |
|
802 |
|
|
|
799 | self.assertIn("AliasManager.default_aliases", matches) | |
|
803 | 800 | s, matches = c.complete(None, "%config AliasManager.") |
|
804 |
|
|
|
801 | self.assertIn("AliasManager.default_aliases", matches) | |
|
805 | 802 | s, matches = c.complete(None, "config AliasManager.de") |
|
806 |
|
|
|
803 | self.assertListEqual(["AliasManager.default_aliases"], matches) | |
|
807 | 804 | s, matches = c.complete(None, "config AliasManager.de") |
|
808 |
|
|
|
805 | self.assertListEqual(["AliasManager.default_aliases"], matches) | |
|
809 | 806 | |
|
810 | 807 | def test_magic_color(self): |
|
811 | 808 | ip = get_ipython() |
|
812 | 809 | c = ip.Completer |
|
813 | 810 | |
|
814 | 811 | s, matches = c.complete(None, "colo") |
|
815 |
|
|
|
812 | self.assertIn("%colors", matches) | |
|
816 | 813 | s, matches = c.complete(None, "colo") |
|
817 |
|
|
|
814 | self.assertNotIn("NoColor", matches) | |
|
818 | 815 | s, matches = c.complete(None, "%colors") # No trailing space |
|
819 |
|
|
|
816 | self.assertNotIn("NoColor", matches) | |
|
820 | 817 | s, matches = c.complete(None, "colors ") |
|
821 |
|
|
|
818 | self.assertIn("NoColor", matches) | |
|
822 | 819 | s, matches = c.complete(None, "%colors ") |
|
823 |
|
|
|
820 | self.assertIn("NoColor", matches) | |
|
824 | 821 | s, matches = c.complete(None, "colors NoCo") |
|
825 |
|
|
|
822 | self.assertListEqual(["NoColor"], matches) | |
|
826 | 823 | s, matches = c.complete(None, "%colors NoCo") |
|
827 |
|
|
|
824 | self.assertListEqual(["NoColor"], matches) | |
|
828 | 825 | |
|
829 | 826 | def test_match_dict_keys(self): |
|
830 | 827 | """ |
@@ -884,34 +881,34 b' class TestCompleter(unittest.TestCase):' | |||
|
884 | 881 | |
|
885 | 882 | # check completion at different stages |
|
886 | 883 | _, matches = complete(line_buffer="d[") |
|
887 |
|
|
|
888 |
|
|
|
884 | self.assertIn("'abc'", matches) | |
|
885 | self.assertNotIn("'abc']", matches) | |
|
889 | 886 | |
|
890 | 887 | _, matches = complete(line_buffer="d['") |
|
891 |
|
|
|
892 |
|
|
|
888 | self.assertIn("abc", matches) | |
|
889 | self.assertNotIn("abc']", matches) | |
|
893 | 890 | |
|
894 | 891 | _, matches = complete(line_buffer="d['a") |
|
895 |
|
|
|
896 |
|
|
|
892 | self.assertIn("abc", matches) | |
|
893 | self.assertNotIn("abc']", matches) | |
|
897 | 894 | |
|
898 | 895 | # check use of different quoting |
|
899 | 896 | _, matches = complete(line_buffer='d["') |
|
900 |
|
|
|
901 |
|
|
|
897 | self.assertIn("abc", matches) | |
|
898 | self.assertNotIn('abc"]', matches) | |
|
902 | 899 | |
|
903 | 900 | _, matches = complete(line_buffer='d["a') |
|
904 |
|
|
|
905 |
|
|
|
901 | self.assertIn("abc", matches) | |
|
902 | self.assertNotIn('abc"]', matches) | |
|
906 | 903 | |
|
907 | 904 | # check sensitivity to following context |
|
908 | 905 | _, matches = complete(line_buffer="d[]", cursor_pos=2) |
|
909 |
|
|
|
906 | self.assertIn("'abc'", matches) | |
|
910 | 907 | |
|
911 | 908 | _, matches = complete(line_buffer="d['']", cursor_pos=3) |
|
912 |
|
|
|
913 |
|
|
|
914 |
|
|
|
909 | self.assertIn("abc", matches) | |
|
910 | self.assertNotIn("abc'", matches) | |
|
911 | self.assertNotIn("abc']", matches) | |
|
915 | 912 | |
|
916 | 913 | # check multiple solutions are correctly returned and that noise is not |
|
917 | 914 | ip.user_ns["d"] = { |
@@ -925,111 +922,110 b' class TestCompleter(unittest.TestCase):' | |||
|
925 | 922 | } |
|
926 | 923 | |
|
927 | 924 | _, matches = complete(line_buffer="d['a") |
|
928 |
|
|
|
929 |
|
|
|
930 |
|
|
|
931 |
|
|
|
932 |
|
|
|
925 | self.assertIn("abc", matches) | |
|
926 | self.assertIn("abd", matches) | |
|
927 | self.assertNotIn("bad", matches) | |
|
928 | self.assertNotIn("abe", matches) | |
|
929 | self.assertNotIn("abf", matches) | |
|
933 | 930 | assert not any(m.endswith(("]", '"', "'")) for m in matches), matches |
|
934 | 931 | |
|
935 | 932 | # check escaping and whitespace |
|
936 | 933 | ip.user_ns["d"] = {"a\nb": None, "a'b": None, 'a"b': None, "a word": None} |
|
937 | 934 | _, matches = complete(line_buffer="d['a") |
|
938 |
|
|
|
939 |
|
|
|
940 |
|
|
|
941 |
|
|
|
935 | self.assertIn("a\\nb", matches) | |
|
936 | self.assertIn("a\\'b", matches) | |
|
937 | self.assertIn('a"b', matches) | |
|
938 | self.assertIn("a word", matches) | |
|
942 | 939 | assert not any(m.endswith(("]", '"', "'")) for m in matches), matches |
|
943 | 940 | |
|
944 | 941 | # - can complete on non-initial word of the string |
|
945 | 942 | _, matches = complete(line_buffer="d['a w") |
|
946 |
|
|
|
943 | self.assertIn("word", matches) | |
|
947 | 944 | |
|
948 | 945 | # - understands quote escaping |
|
949 | 946 | _, matches = complete(line_buffer="d['a\\'") |
|
950 |
|
|
|
947 | self.assertIn("b", matches) | |
|
951 | 948 | |
|
952 | 949 | # - default quoting should work like repr |
|
953 | 950 | _, matches = complete(line_buffer="d[") |
|
954 |
|
|
|
951 | self.assertIn('"a\'b"', matches) | |
|
955 | 952 | |
|
956 | 953 | # - when opening quote with ", possible to match with unescaped apostrophe |
|
957 | 954 | _, matches = complete(line_buffer="d[\"a'") |
|
958 |
|
|
|
955 | self.assertIn("b", matches) | |
|
959 | 956 | |
|
960 | 957 | # need to not split at delims that readline won't split at |
|
961 | 958 | if "-" not in ip.Completer.splitter.delims: |
|
962 | 959 | ip.user_ns["d"] = {"before-after": None} |
|
963 | 960 | _, matches = complete(line_buffer="d['before-af") |
|
964 |
|
|
|
961 | self.assertIn("before-after", matches) | |
|
965 | 962 | |
|
966 | 963 | # check completion on tuple-of-string keys at different stage - on first key |
|
967 | 964 | ip.user_ns["d"] = {('foo', 'bar'): None} |
|
968 | 965 | _, matches = complete(line_buffer="d[") |
|
969 |
|
|
|
970 |
|
|
|
971 |
|
|
|
972 |
|
|
|
973 |
|
|
|
966 | self.assertIn("'foo'", matches) | |
|
967 | self.assertNotIn("'foo']", matches) | |
|
968 | self.assertNotIn("'bar'", matches) | |
|
969 | self.assertNotIn("foo", matches) | |
|
970 | self.assertNotIn("bar", matches) | |
|
974 | 971 | |
|
975 | 972 | # - match the prefix |
|
976 | 973 | _, matches = complete(line_buffer="d['f") |
|
977 |
|
|
|
978 |
|
|
|
979 |
|
|
|
974 | self.assertIn("foo", matches) | |
|
975 | self.assertNotIn("foo']", matches) | |
|
976 | self.assertNotIn('foo"]', matches) | |
|
980 | 977 | _, matches = complete(line_buffer="d['foo") |
|
981 |
|
|
|
978 | self.assertIn("foo", matches) | |
|
982 | 979 | |
|
983 | 980 | # - can complete on second key |
|
984 | 981 | _, matches = complete(line_buffer="d['foo', ") |
|
985 |
|
|
|
982 | self.assertIn("'bar'", matches) | |
|
986 | 983 | _, matches = complete(line_buffer="d['foo', 'b") |
|
987 |
|
|
|
988 |
|
|
|
984 | self.assertIn("bar", matches) | |
|
985 | self.assertNotIn("foo", matches) | |
|
989 | 986 | |
|
990 | 987 | # - does not propose missing keys |
|
991 | 988 | _, matches = complete(line_buffer="d['foo', 'f") |
|
992 |
|
|
|
993 |
|
|
|
989 | self.assertNotIn("bar", matches) | |
|
990 | self.assertNotIn("foo", matches) | |
|
994 | 991 | |
|
995 | 992 | # check sensitivity to following context |
|
996 | 993 | _, matches = complete(line_buffer="d['foo',]", cursor_pos=8) |
|
997 |
|
|
|
998 |
|
|
|
999 |
|
|
|
1000 |
|
|
|
994 | self.assertIn("'bar'", matches) | |
|
995 | self.assertNotIn("bar", matches) | |
|
996 | self.assertNotIn("'foo'", matches) | |
|
997 | self.assertNotIn("foo", matches) | |
|
1001 | 998 | |
|
1002 | 999 | _, matches = complete(line_buffer="d['']", cursor_pos=3) |
|
1003 |
|
|
|
1000 | self.assertIn("foo", matches) | |
|
1004 | 1001 | assert not any(m.endswith(("]", '"', "'")) for m in matches), matches |
|
1005 | 1002 | |
|
1006 | 1003 | _, matches = complete(line_buffer='d[""]', cursor_pos=3) |
|
1007 |
|
|
|
1004 | self.assertIn("foo", matches) | |
|
1008 | 1005 | assert not any(m.endswith(("]", '"', "'")) for m in matches), matches |
|
1009 | 1006 | |
|
1010 | 1007 | _, matches = complete(line_buffer='d["foo","]', cursor_pos=9) |
|
1011 |
|
|
|
1008 | self.assertIn("bar", matches) | |
|
1012 | 1009 | assert not any(m.endswith(("]", '"', "'")) for m in matches), matches |
|
1013 | 1010 | |
|
1014 | 1011 | _, matches = complete(line_buffer='d["foo",]', cursor_pos=8) |
|
1015 |
|
|
|
1016 |
|
|
|
1012 | self.assertIn("'bar'", matches) | |
|
1013 | self.assertNotIn("bar", matches) | |
|
1017 | 1014 | |
|
1018 | 1015 | # Can complete with longer tuple keys |
|
1019 | 1016 | ip.user_ns["d"] = {('foo', 'bar', 'foobar'): None} |
|
1020 | 1017 | |
|
1021 | 1018 | # - can complete second key |
|
1022 | 1019 | _, matches = complete(line_buffer="d['foo', 'b") |
|
1023 |
|
|
|
1024 |
|
|
|
1025 |
|
|
|
1020 | self.assertIn("bar", matches) | |
|
1021 | self.assertNotIn("foo", matches) | |
|
1022 | self.assertNotIn("foobar", matches) | |
|
1026 | 1023 | |
|
1027 | 1024 | # - can complete third key |
|
1028 | 1025 | _, matches = complete(line_buffer="d['foo', 'bar', 'fo") |
|
1029 |
|
|
|
1030 |
|
|
|
1031 |
|
|
|
1032 | ||
|
1026 | self.assertIn("foobar", matches) | |
|
1027 | self.assertNotIn("foo", matches) | |
|
1028 | self.assertNotIn("bar", matches) | |
|
1033 | 1029 | |
|
1034 | 1030 | def test_dict_key_completion_contexts(self): |
|
1035 | 1031 | """Test expression contexts in which dict key completion occurs""" |
@@ -1046,16 +1042,16 b' class TestCompleter(unittest.TestCase):' | |||
|
1046 | 1042 | |
|
1047 | 1043 | def assert_no_completion(**kwargs): |
|
1048 | 1044 | _, matches = complete(**kwargs) |
|
1049 |
|
|
|
1050 |
|
|
|
1051 |
|
|
|
1052 |
|
|
|
1053 |
|
|
|
1045 | self.assertNotIn("abc", matches) | |
|
1046 | self.assertNotIn("abc'", matches) | |
|
1047 | self.assertNotIn("abc']", matches) | |
|
1048 | self.assertNotIn("'abc'", matches) | |
|
1049 | self.assertNotIn("'abc']", matches) | |
|
1054 | 1050 | |
|
1055 | 1051 | def assert_completion(**kwargs): |
|
1056 | 1052 | _, matches = complete(**kwargs) |
|
1057 |
|
|
|
1058 |
|
|
|
1053 | self.assertIn("'abc'", matches) | |
|
1054 | self.assertNotIn("'abc']", matches) | |
|
1059 | 1055 | |
|
1060 | 1056 | # no completion after string closed, even if reopened |
|
1061 | 1057 | assert_no_completion(line_buffer="d['a'") |
@@ -1071,7 +1067,7 b' class TestCompleter(unittest.TestCase):' | |||
|
1071 | 1067 | # greedy flag |
|
1072 | 1068 | def assert_completion(**kwargs): |
|
1073 | 1069 | _, matches = complete(**kwargs) |
|
1074 |
|
|
|
1070 | self.assertIn("get()['abc']", matches) | |
|
1075 | 1071 | |
|
1076 | 1072 | assert_no_completion(line_buffer="get()[") |
|
1077 | 1073 | with greedy_completion(): |
@@ -1089,25 +1085,25 b' class TestCompleter(unittest.TestCase):' | |||
|
1089 | 1085 | ip.user_ns["d"] = {"abc": None, b"abd": None} |
|
1090 | 1086 | |
|
1091 | 1087 | _, matches = complete(line_buffer="d[") |
|
1092 |
|
|
|
1093 |
|
|
|
1088 | self.assertIn("'abc'", matches) | |
|
1089 | self.assertIn("b'abd'", matches) | |
|
1094 | 1090 | |
|
1095 | 1091 | if False: # not currently implemented |
|
1096 | 1092 | _, matches = complete(line_buffer="d[b") |
|
1097 |
|
|
|
1098 |
|
|
|
1093 | self.assertIn("b'abd'", matches) | |
|
1094 | self.assertNotIn("b'abc'", matches) | |
|
1099 | 1095 | |
|
1100 | 1096 | _, matches = complete(line_buffer="d[b'") |
|
1101 |
|
|
|
1102 |
|
|
|
1097 | self.assertIn("abd", matches) | |
|
1098 | self.assertNotIn("abc", matches) | |
|
1103 | 1099 | |
|
1104 | 1100 | _, matches = complete(line_buffer="d[B'") |
|
1105 |
|
|
|
1106 |
|
|
|
1101 | self.assertIn("abd", matches) | |
|
1102 | self.assertNotIn("abc", matches) | |
|
1107 | 1103 | |
|
1108 | 1104 | _, matches = complete(line_buffer="d['") |
|
1109 |
|
|
|
1110 |
|
|
|
1105 | self.assertIn("abc", matches) | |
|
1106 | self.assertNotIn("abd", matches) | |
|
1111 | 1107 | |
|
1112 | 1108 | def test_dict_key_completion_unicode_py3(self): |
|
1113 | 1109 | """Test handling of unicode in dict key completion""" |
@@ -1120,20 +1116,20 b' class TestCompleter(unittest.TestCase):' | |||
|
1120 | 1116 | if sys.platform != "win32": |
|
1121 | 1117 | # Known failure on Windows |
|
1122 | 1118 | _, matches = complete(line_buffer="d['a\\u05d0") |
|
1123 |
|
|
|
1119 | self.assertIn("u05d0", matches) # tokenized after \\ | |
|
1124 | 1120 | |
|
1125 | 1121 | # query using character |
|
1126 | 1122 | _, matches = complete(line_buffer="d['a\u05d0") |
|
1127 |
|
|
|
1123 | self.assertIn("a\u05d0", matches) | |
|
1128 | 1124 | |
|
1129 | 1125 | with greedy_completion(): |
|
1130 | 1126 | # query using escape |
|
1131 | 1127 | _, matches = complete(line_buffer="d['a\\u05d0") |
|
1132 |
|
|
|
1128 | self.assertIn("d['a\\u05d0']", matches) # tokenized after \\ | |
|
1133 | 1129 | |
|
1134 | 1130 | # query using character |
|
1135 | 1131 | _, matches = complete(line_buffer="d['a\u05d0") |
|
1136 |
|
|
|
1132 | self.assertIn("d['a\u05d0']", matches) | |
|
1137 | 1133 | |
|
1138 | 1134 | @dec.skip_without("numpy") |
|
1139 | 1135 | def test_struct_array_key_completion(self): |
@@ -1144,8 +1140,8 b' class TestCompleter(unittest.TestCase):' | |||
|
1144 | 1140 | complete = ip.Completer.complete |
|
1145 | 1141 | ip.user_ns["d"] = numpy.array([], dtype=[("hello", "f"), ("world", "f")]) |
|
1146 | 1142 | _, matches = complete(line_buffer="d['") |
|
1147 |
|
|
|
1148 |
|
|
|
1143 | self.assertIn("hello", matches) | |
|
1144 | self.assertIn("world", matches) | |
|
1149 | 1145 | # complete on the numpy struct itself |
|
1150 | 1146 | dt = numpy.dtype( |
|
1151 | 1147 | [("my_head", [("my_dt", ">u4"), ("my_df", ">u4")]), ("my_data", ">f4", 5)] |
@@ -1153,14 +1149,14 b' class TestCompleter(unittest.TestCase):' | |||
|
1153 | 1149 | x = numpy.zeros(2, dtype=dt) |
|
1154 | 1150 | ip.user_ns["d"] = x[1] |
|
1155 | 1151 | _, matches = complete(line_buffer="d['") |
|
1156 |
|
|
|
1157 |
|
|
|
1152 | self.assertIn("my_head", matches) | |
|
1153 | self.assertIn("my_data", matches) | |
|
1158 | 1154 | # complete on a nested level |
|
1159 | 1155 | with greedy_completion(): |
|
1160 | 1156 | ip.user_ns["d"] = numpy.zeros(2, dtype=dt) |
|
1161 | 1157 | _, matches = complete(line_buffer="d[1]['my_head']['") |
|
1162 |
|
|
|
1163 |
|
|
|
1158 | self.assertTrue(any(["my_dt" in m for m in matches])) | |
|
1159 | self.assertTrue(any(["my_df" in m for m in matches])) | |
|
1164 | 1160 | |
|
1165 | 1161 | @dec.skip_without("pandas") |
|
1166 | 1162 | def test_dataframe_key_completion(self): |
@@ -1171,8 +1167,8 b' class TestCompleter(unittest.TestCase):' | |||
|
1171 | 1167 | complete = ip.Completer.complete |
|
1172 | 1168 | ip.user_ns["d"] = pandas.DataFrame({"hello": [1], "world": [2]}) |
|
1173 | 1169 | _, matches = complete(line_buffer="d['") |
|
1174 |
|
|
|
1175 |
|
|
|
1170 | self.assertIn("hello", matches) | |
|
1171 | self.assertIn("world", matches) | |
|
1176 | 1172 | |
|
1177 | 1173 | def test_dict_key_completion_invalids(self): |
|
1178 | 1174 | """Smoke test cases dict key completion can't handle""" |
@@ -1197,8 +1193,8 b' class TestCompleter(unittest.TestCase):' | |||
|
1197 | 1193 | ip.user_ns["key_completable"] = KeyCompletable(["qwerty", "qwick"]) |
|
1198 | 1194 | |
|
1199 | 1195 | _, matches = ip.Completer.complete(line_buffer="key_completable['qw") |
|
1200 |
|
|
|
1201 |
|
|
|
1196 | self.assertIn("qwerty", matches) | |
|
1197 | self.assertIn("qwick", matches) | |
|
1202 | 1198 | |
|
1203 | 1199 | def test_class_key_completion(self): |
|
1204 | 1200 | ip = get_ipython() |
@@ -1207,8 +1203,8 b' class TestCompleter(unittest.TestCase):' | |||
|
1207 | 1203 | ip.user_ns["named_instance_class"] = NamedInstanceClass |
|
1208 | 1204 | |
|
1209 | 1205 | _, matches = ip.Completer.complete(line_buffer="named_instance_class['qw") |
|
1210 |
|
|
|
1211 |
|
|
|
1206 | self.assertIn("qwerty", matches) | |
|
1207 | self.assertIn("qwick", matches) | |
|
1212 | 1208 | |
|
1213 | 1209 | def test_tryimport(self): |
|
1214 | 1210 | """ |
@@ -1221,27 +1217,27 b' class TestCompleter(unittest.TestCase):' | |||
|
1221 | 1217 | def test_aimport_module_completer(self): |
|
1222 | 1218 | ip = get_ipython() |
|
1223 | 1219 | _, matches = ip.complete("i", "%aimport i") |
|
1224 |
|
|
|
1225 |
|
|
|
1220 | self.assertIn("io", matches) | |
|
1221 | self.assertNotIn("int", matches) | |
|
1226 | 1222 | |
|
1227 | 1223 | def test_nested_import_module_completer(self): |
|
1228 | 1224 | ip = get_ipython() |
|
1229 | 1225 | _, matches = ip.complete(None, "import IPython.co", 17) |
|
1230 |
|
|
|
1231 |
|
|
|
1232 |
|
|
|
1226 | self.assertIn("IPython.core", matches) | |
|
1227 | self.assertNotIn("import IPython.core", matches) | |
|
1228 | self.assertNotIn("IPython.display", matches) | |
|
1233 | 1229 | |
|
1234 | 1230 | def test_import_module_completer(self): |
|
1235 | 1231 | ip = get_ipython() |
|
1236 | 1232 | _, matches = ip.complete("i", "import i") |
|
1237 |
|
|
|
1238 |
|
|
|
1233 | self.assertIn("io", matches) | |
|
1234 | self.assertNotIn("int", matches) | |
|
1239 | 1235 | |
|
1240 | 1236 | def test_from_module_completer(self): |
|
1241 | 1237 | ip = get_ipython() |
|
1242 | 1238 | _, matches = ip.complete("B", "from io import B", 16) |
|
1243 |
|
|
|
1244 |
|
|
|
1239 | self.assertIn("BytesIO", matches) | |
|
1240 | self.assertNotIn("BaseException", matches) | |
|
1245 | 1241 | |
|
1246 | 1242 | def test_snake_case_completion(self): |
|
1247 | 1243 | ip = get_ipython() |
@@ -1249,8 +1245,8 b' class TestCompleter(unittest.TestCase):' | |||
|
1249 | 1245 | ip.user_ns["some_three"] = 3 |
|
1250 | 1246 | ip.user_ns["some_four"] = 4 |
|
1251 | 1247 | _, matches = ip.complete("s_", "print(s_f") |
|
1252 |
|
|
|
1253 |
|
|
|
1248 | self.assertIn("some_three", matches) | |
|
1249 | self.assertIn("some_four", matches) | |
|
1254 | 1250 | |
|
1255 | 1251 | def test_mix_terms(self): |
|
1256 | 1252 | ip = get_ipython() |
@@ -1274,5 +1270,5 b' class TestCompleter(unittest.TestCase):' | |||
|
1274 | 1270 | ) |
|
1275 | 1271 | ) |
|
1276 | 1272 | _, matches = ip.complete(None, "test.meth(") |
|
1277 |
|
|
|
1278 |
|
|
|
1273 | self.assertIn("meth_arg1=", matches) | |
|
1274 | self.assertNotIn("meth2_arg1=", matches) |
@@ -14,8 +14,6 b' import tempfile' | |||
|
14 | 14 | import unittest |
|
15 | 15 | from os.path import join |
|
16 | 16 | |
|
17 | import nose.tools as nt | |
|
18 | ||
|
19 | 17 | from IPython.core.completerlib import magic_run_completer, module_completion, try_import |
|
20 | 18 | from IPython.utils.tempdir import TemporaryDirectory |
|
21 | 19 | from IPython.testing.decorators import onlyif_unicode_paths |
@@ -140,7 +138,7 b' def test_import_invalid_module():' | |||
|
140 | 138 | |
|
141 | 139 | s = set( module_completion('import foo') ) |
|
142 | 140 | intersection = s.intersection(invalid_module_names) |
|
143 |
|
|
|
141 | assert intersection == set() | |
|
144 | 142 | |
|
145 | 143 | assert valid_module_names.issubset(s), valid_module_names.intersection(s) |
|
146 | 144 | |
@@ -153,15 +151,15 b' def test_bad_module_all():' | |||
|
153 | 151 | testsdir = os.path.dirname(__file__) |
|
154 | 152 | sys.path.insert(0, testsdir) |
|
155 | 153 | try: |
|
156 |
results = module_completion( |
|
|
157 |
|
|
|
154 | results = module_completion("from bad_all import ") | |
|
155 | assert "puppies" in results | |
|
158 | 156 | for r in results: |
|
159 |
|
|
|
157 | assert isinstance(r, str) | |
|
160 | 158 | |
|
161 | 159 | # bad_all doesn't contain submodules, but this completion |
|
162 | 160 | # should finish without raising an exception: |
|
163 | 161 | results = module_completion("import bad_all.") |
|
164 |
|
|
|
162 | assert results == [] | |
|
165 | 163 | finally: |
|
166 | 164 | sys.path.remove(testsdir) |
|
167 | 165 | |
@@ -189,6 +187,6 b' def test_valid_exported_submodules():' | |||
|
189 | 187 | """ |
|
190 | 188 | results = module_completion("import os.pa") |
|
191 | 189 | # ensure we get a valid submodule: |
|
192 |
|
|
|
190 | assert "os.path" in results | |
|
193 | 191 | # ensure we don't get objects that aren't submodules: |
|
194 |
|
|
|
192 | assert "os.pathconf" not in results |
@@ -18,8 +18,6 b' from tempfile import NamedTemporaryFile' | |||
|
18 | 18 | from textwrap import dedent |
|
19 | 19 | from unittest.mock import patch |
|
20 | 20 | |
|
21 | import nose.tools as nt | |
|
22 | ||
|
23 | 21 | from IPython.core import debugger |
|
24 | 22 | from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE |
|
25 | 23 | from IPython.testing.decorators import skip_win32 |
@@ -66,13 +64,13 b' def test_longer_repr():' | |||
|
66 | 64 | a = '1234567890'* 7 |
|
67 | 65 | ar = "'1234567890123456789012345678901234567890123456789012345678901234567890'" |
|
68 | 66 | a_trunc = "'123456789012...8901234567890'" |
|
69 |
|
|
|
67 | assert trepr(a) == a_trunc | |
|
70 | 68 | # The creation of our tracer modifies the repr module's repr function |
|
71 | 69 | # in-place, since that global is used directly by the stdlib's pdb module. |
|
72 | 70 | with warnings.catch_warnings(): |
|
73 | 71 | warnings.simplefilter('ignore', DeprecationWarning) |
|
74 | 72 | debugger.Tracer() |
|
75 |
|
|
|
73 | assert trepr(a) == ar | |
|
76 | 74 | |
|
77 | 75 | def test_ipdb_magics(): |
|
78 | 76 | '''Test calling some IPython magics from ipdb. |
@@ -7,7 +7,7 b' import warnings' | |||
|
7 | 7 | |
|
8 | 8 | from unittest import mock |
|
9 | 9 | |
|
10 | import nose.tools as nt | |
|
10 | import pytest | |
|
11 | 11 | |
|
12 | 12 | from IPython import display |
|
13 | 13 | from IPython.core.getipython import get_ipython |
@@ -22,15 +22,15 b' def test_image_size():' | |||
|
22 | 22 | """Simple test for display.Image(args, width=x,height=y)""" |
|
23 | 23 | thisurl = 'http://www.google.fr/images/srpr/logo3w.png' |
|
24 | 24 | img = display.Image(url=thisurl, width=200, height=200) |
|
25 |
|
|
|
25 | assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_() | |
|
26 | 26 | img = display.Image(url=thisurl, metadata={'width':200, 'height':200}) |
|
27 |
|
|
|
27 | assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_() | |
|
28 | 28 | img = display.Image(url=thisurl, width=200) |
|
29 |
|
|
|
29 | assert '<img src="%s" width="200"/>' % (thisurl) == img._repr_html_() | |
|
30 | 30 | img = display.Image(url=thisurl) |
|
31 |
|
|
|
31 | assert '<img src="%s"/>' % (thisurl) == img._repr_html_() | |
|
32 | 32 | img = display.Image(url=thisurl, unconfined=True) |
|
33 |
|
|
|
33 | assert '<img src="%s" class="unconfined"/>' % (thisurl) == img._repr_html_() | |
|
34 | 34 | |
|
35 | 35 | |
|
36 | 36 | def test_image_mimes(): |
@@ -39,7 +39,7 b' def test_image_mimes():' | |||
|
39 | 39 | mime = display.Image._MIMETYPES[format] |
|
40 | 40 | img = display.Image(b'garbage', format=format) |
|
41 | 41 | data, metadata = fmt(img) |
|
42 |
|
|
|
42 | assert sorted(data) == sorted([mime, "text/plain"]) | |
|
43 | 43 | |
|
44 | 44 | |
|
45 | 45 | def test_geojson(): |
@@ -60,17 +60,20 b' def test_geojson():' | |||
|
60 | 60 | "attribution": "Celestia/praesepe", |
|
61 | 61 | "minZoom": 0, |
|
62 | 62 | "maxZoom": 18, |
|
63 |
} |
|
|
64 | nt.assert_equal(u'<IPython.core.display.GeoJSON object>', str(gj)) | |
|
63 | }, | |
|
64 | ) | |
|
65 | assert "<IPython.core.display.GeoJSON object>" == str(gj) | |
|
66 | ||
|
65 | 67 | |
|
66 | 68 | def test_retina_png(): |
|
67 | 69 | here = os.path.dirname(__file__) |
|
68 | 70 | img = display.Image(os.path.join(here, "2x2.png"), retina=True) |
|
69 |
|
|
|
70 |
|
|
|
71 | assert img.height == 1 | |
|
72 | assert img.width == 1 | |
|
71 | 73 | data, md = img._repr_png_() |
|
72 |
|
|
|
73 |
|
|
|
74 | assert md["width"] == 1 | |
|
75 | assert md["height"] == 1 | |
|
76 | ||
|
74 | 77 | |
|
75 | 78 | def test_embed_svg_url(): |
|
76 | 79 | import gzip |
@@ -102,18 +105,20 b' def test_embed_svg_url():' | |||
|
102 | 105 | |
|
103 | 106 | with mock.patch('urllib.request.urlopen', side_effect=mocked_urlopen): |
|
104 | 107 | svg = display.SVG(url=url) |
|
105 |
|
|
|
106 |
svg = display.SVG(url=url + |
|
|
107 |
|
|
|
108 | assert svg._repr_svg_().startswith("<svg") is True | |
|
109 | svg = display.SVG(url=url + "z") | |
|
110 | assert svg._repr_svg_().startswith("<svg") is True | |
|
111 | ||
|
108 | 112 | |
|
109 | 113 | def test_retina_jpeg(): |
|
110 | 114 | here = os.path.dirname(__file__) |
|
111 | 115 | img = display.Image(os.path.join(here, "2x2.jpg"), retina=True) |
|
112 |
|
|
|
113 |
|
|
|
116 | assert img.height == 1 | |
|
117 | assert img.width == 1 | |
|
114 | 118 | data, md = img._repr_jpeg_() |
|
115 |
|
|
|
116 |
|
|
|
119 | assert md["width"] == 1 | |
|
120 | assert md["height"] == 1 | |
|
121 | ||
|
117 | 122 | |
|
118 | 123 | def test_base64image(): |
|
119 | 124 | display.Image("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAWJLR0QAiAUdSAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB94BCRQnOqNu0b4AAAAKSURBVAjXY2AAAAACAAHiIbwzAAAAAElFTkSuQmCC") |
@@ -121,18 +126,30 b' def test_base64image():' | |||
|
121 | 126 | def test_image_filename_defaults(): |
|
122 | 127 | '''test format constraint, and validity of jpeg and png''' |
|
123 | 128 | tpath = ipath.get_ipython_package_dir() |
|
124 | nt.assert_raises(ValueError, display.Image, filename=os.path.join(tpath, 'testing/tests/badformat.zip'), | |
|
125 | embed=True) | |
|
126 | nt.assert_raises(ValueError, display.Image) | |
|
127 | nt.assert_raises(ValueError, display.Image, data='this is not an image', format='badformat', embed=True) | |
|
128 | # check both paths to allow packages to test at build and install time | |
|
129 | pytest.raises( | |
|
130 | ValueError, | |
|
131 | display.Image, | |
|
132 | filename=os.path.join(tpath, "testing/tests/badformat.zip"), | |
|
133 | embed=True, | |
|
134 | ) | |
|
135 | pytest.raises(ValueError, display.Image) | |
|
136 | pytest.raises( | |
|
137 | ValueError, | |
|
138 | display.Image, | |
|
139 | data="this is not an image", | |
|
140 | format="badformat", | |
|
141 | embed=True, | |
|
142 | ) | |
|
143 | # check boths paths to allow packages to test at build and install time | |
|
129 | 144 | imgfile = os.path.join(tpath, 'core/tests/2x2.png') |
|
130 | 145 | img = display.Image(filename=imgfile) |
|
131 |
|
|
|
132 |
|
|
|
133 | img = display.Image(filename=os.path.join(tpath, 'testing/tests/logo.jpg'), embed=False) | |
|
134 | nt.assert_equal('jpeg', img.format) | |
|
135 | nt.assert_is_none(img._repr_jpeg_()) | |
|
146 | assert "png" == img.format | |
|
147 | assert img._repr_png_() is not None | |
|
148 | img = display.Image( | |
|
149 | filename=os.path.join(tpath, "testing/tests/logo.jpg"), embed=False | |
|
150 | ) | |
|
151 | assert "jpeg" == img.format | |
|
152 | assert img._repr_jpeg_() is None | |
|
136 | 153 | |
|
137 | 154 | def _get_inline_config(): |
|
138 | 155 | from matplotlib_inline.config import InlineBackend |
@@ -171,9 +188,9 b' def test_set_matplotlib_formats():' | |||
|
171 | 188 | display.set_matplotlib_formats(*formats) |
|
172 | 189 | for mime, f in formatters.items(): |
|
173 | 190 | if mime in active_mimes: |
|
174 |
|
|
|
191 | assert Figure in f | |
|
175 | 192 | else: |
|
176 |
|
|
|
193 | assert Figure not in f | |
|
177 | 194 | |
|
178 | 195 | |
|
179 | 196 | @dec.skip_without("ipykernel") |
@@ -192,7 +209,7 b' def test_set_matplotlib_formats_kwargs():' | |||
|
192 | 209 | expected["base64"] = True |
|
193 | 210 | expected["fmt"] = "png" |
|
194 | 211 | expected.update(cfg.print_figure_kwargs) |
|
195 |
|
|
|
212 | assert formatter_kwargs == expected | |
|
196 | 213 | |
|
197 | 214 | def test_display_available(): |
|
198 | 215 | """ |
@@ -213,27 +230,28 b' def test_display_available():' | |||
|
213 | 230 | ip.run_cell('display') |
|
214 | 231 | |
|
215 | 232 | def test_textdisplayobj_pretty_repr(): |
|
216 |
|
|
|
217 |
|
|
|
218 |
|
|
|
233 | p = display.Pretty("This is a simple test") | |
|
234 | assert repr(p) == "<IPython.core.display.Pretty object>" | |
|
235 | assert p.data == "This is a simple test" | |
|
236 | ||
|
237 | p._show_mem_addr = True | |
|
238 | assert repr(p) == object.__repr__(p) | |
|
219 | 239 | |
|
220 | p._show_mem_addr = True | |
|
221 | nt.assert_equal(repr(p), object.__repr__(p)) | |
|
222 | 240 | |
|
223 | 241 | def test_displayobject_repr(): |
|
224 |
h = display.HTML( |
|
|
225 |
|
|
|
242 | h = display.HTML("<br />") | |
|
243 | assert repr(h) == "<IPython.core.display.HTML object>" | |
|
226 | 244 | h._show_mem_addr = True |
|
227 |
|
|
|
245 | assert repr(h) == object.__repr__(h) | |
|
228 | 246 | h._show_mem_addr = False |
|
229 |
|
|
|
247 | assert repr(h) == "<IPython.core.display.HTML object>" | |
|
230 | 248 | |
|
231 |
j = display.Javascript( |
|
|
232 |
|
|
|
249 | j = display.Javascript("") | |
|
250 | assert repr(j) == "<IPython.core.display.Javascript object>" | |
|
233 | 251 | j._show_mem_addr = True |
|
234 |
|
|
|
252 | assert repr(j) == object.__repr__(j) | |
|
235 | 253 | j._show_mem_addr = False |
|
236 |
|
|
|
254 | assert repr(j) == "<IPython.core.display.Javascript object>" | |
|
237 | 255 | |
|
238 | 256 | @mock.patch('warnings.warn') |
|
239 | 257 | def test_encourage_iframe_over_html(m_warn): |
@@ -255,18 +273,22 b' def test_encourage_iframe_over_html(m_warn):' | |||
|
255 | 273 | |
|
256 | 274 | def test_progress(): |
|
257 | 275 | p = display.ProgressBar(10) |
|
258 |
|
|
|
259 |
p.html_width = |
|
|
276 | assert "0/10" in repr(p) | |
|
277 | p.html_width = "100%" | |
|
260 | 278 | p.progress = 5 |
|
261 | nt.assert_equal(p._repr_html_(), "<progress style='width:100%' max='10' value='5'></progress>") | |
|
279 | assert ( | |
|
280 | p._repr_html_() == "<progress style='width:100%' max='10' value='5'></progress>" | |
|
281 | ) | |
|
282 | ||
|
262 | 283 | |
|
263 | 284 | def test_progress_iter(): |
|
264 | 285 | with capture_output(display=False) as captured: |
|
265 | 286 | for i in display.ProgressBar(5): |
|
266 | 287 | out = captured.stdout |
|
267 |
|
|
|
288 | assert "{0}/5".format(i) in out | |
|
268 | 289 | out = captured.stdout |
|
269 |
|
|
|
290 | assert "5/5" in out | |
|
291 | ||
|
270 | 292 | |
|
271 | 293 | def test_json(): |
|
272 | 294 | d = {'a': 5} |
@@ -284,13 +306,13 b' def test_json():' | |||
|
284 | 306 | display.JSON(d, expanded=True, root='custom'), |
|
285 | 307 | ] |
|
286 | 308 | for j, md in zip(json_objs, metadata): |
|
287 |
|
|
|
309 | assert j._repr_json_() == (d, md) | |
|
288 | 310 | |
|
289 | 311 | with warnings.catch_warnings(record=True) as w: |
|
290 | 312 | warnings.simplefilter("always") |
|
291 | 313 | j = display.JSON(json.dumps(d)) |
|
292 |
|
|
|
293 |
|
|
|
314 | assert len(w) == 1 | |
|
315 | assert j._repr_json_() == (d, metadata[0]) | |
|
294 | 316 | |
|
295 | 317 | json_objs = [ |
|
296 | 318 | display.JSON(lis), |
@@ -299,23 +321,24 b' def test_json():' | |||
|
299 | 321 | display.JSON(lis, expanded=True, root='custom'), |
|
300 | 322 | ] |
|
301 | 323 | for j, md in zip(json_objs, metadata): |
|
302 |
|
|
|
324 | assert j._repr_json_() == (lis, md) | |
|
303 | 325 | |
|
304 | 326 | with warnings.catch_warnings(record=True) as w: |
|
305 | 327 | warnings.simplefilter("always") |
|
306 | 328 | j = display.JSON(json.dumps(lis)) |
|
307 |
|
|
|
308 |
|
|
|
329 | assert len(w) == 1 | |
|
330 | assert j._repr_json_() == (lis, metadata[0]) | |
|
331 | ||
|
309 | 332 | |
|
310 | 333 | def test_video_embedding(): |
|
311 | 334 | """use a tempfile, with dummy-data, to ensure that video embedding doesn't crash""" |
|
312 | 335 | v = display.Video("http://ignored") |
|
313 | 336 | assert not v.embed |
|
314 | 337 | html = v._repr_html_() |
|
315 |
|
|
|
316 |
|
|
|
338 | assert 'src="data:' not in html | |
|
339 | assert 'src="http://ignored"' in html | |
|
317 | 340 | |
|
318 |
with |
|
|
341 | with pytest.raises(ValueError): | |
|
319 | 342 | v = display.Video(b'abc') |
|
320 | 343 | |
|
321 | 344 | with NamedFileInTemporaryDirectory('test.mp4') as f: |
@@ -325,52 +348,53 b' def test_video_embedding():' | |||
|
325 | 348 | v = display.Video(f.name) |
|
326 | 349 | assert not v.embed |
|
327 | 350 | html = v._repr_html_() |
|
328 |
|
|
|
351 | assert 'src="data:' not in html | |
|
329 | 352 | |
|
330 | 353 | v = display.Video(f.name, embed=True) |
|
331 | 354 | html = v._repr_html_() |
|
332 |
|
|
|
355 | assert 'src="data:video/mp4;base64,YWJj"' in html | |
|
333 | 356 | |
|
334 | 357 | v = display.Video(f.name, embed=True, mimetype='video/other') |
|
335 | 358 | html = v._repr_html_() |
|
336 |
|
|
|
359 | assert 'src="data:video/other;base64,YWJj"' in html | |
|
337 | 360 | |
|
338 | 361 | v = display.Video(b'abc', embed=True, mimetype='video/mp4') |
|
339 | 362 | html = v._repr_html_() |
|
340 |
|
|
|
363 | assert 'src="data:video/mp4;base64,YWJj"' in html | |
|
341 | 364 | |
|
342 | 365 | v = display.Video(u'YWJj', embed=True, mimetype='video/xyz') |
|
343 | 366 | html = v._repr_html_() |
|
344 |
|
|
|
367 | assert 'src="data:video/xyz;base64,YWJj"' in html | |
|
345 | 368 | |
|
346 | 369 | def test_html_metadata(): |
|
347 | 370 | s = "<h1>Test</h1>" |
|
348 | 371 | h = display.HTML(s, metadata={"isolated": True}) |
|
349 |
|
|
|
372 | assert h._repr_html_() == (s, {"isolated": True}) | |
|
373 | ||
|
350 | 374 | |
|
351 | 375 | def test_display_id(): |
|
352 | 376 | ip = get_ipython() |
|
353 | 377 | with mock.patch.object(ip.display_pub, 'publish') as pub: |
|
354 | 378 | handle = display.display('x') |
|
355 |
|
|
|
379 | assert handle is None | |
|
356 | 380 | handle = display.display('y', display_id='secret') |
|
357 |
|
|
|
381 | assert isinstance(handle, display.DisplayHandle) | |
|
358 | 382 | handle2 = display.display('z', display_id=True) |
|
359 |
|
|
|
360 |
|
|
|
383 | assert isinstance(handle2, display.DisplayHandle) | |
|
384 | assert handle.display_id != handle2.display_id | |
|
361 | 385 | |
|
362 |
|
|
|
386 | assert pub.call_count == 3 | |
|
363 | 387 | args, kwargs = pub.call_args_list[0] |
|
364 |
|
|
|
365 |
|
|
|
388 | assert args == () | |
|
389 | assert kwargs == { | |
|
366 | 390 | 'data': { |
|
367 | 391 | 'text/plain': repr('x') |
|
368 | 392 | }, |
|
369 | 393 | 'metadata': {}, |
|
370 |
} |
|
|
394 | } | |
|
371 | 395 | args, kwargs = pub.call_args_list[1] |
|
372 |
|
|
|
373 |
|
|
|
396 | assert args == () | |
|
397 | assert kwargs == { | |
|
374 | 398 | 'data': { |
|
375 | 399 | 'text/plain': repr('y') |
|
376 | 400 | }, |
@@ -378,10 +402,10 b' def test_display_id():' | |||
|
378 | 402 | 'transient': { |
|
379 | 403 | 'display_id': handle.display_id, |
|
380 | 404 | }, |
|
381 |
} |
|
|
405 | } | |
|
382 | 406 | args, kwargs = pub.call_args_list[2] |
|
383 |
|
|
|
384 |
|
|
|
407 | assert args == () | |
|
408 | assert kwargs == { | |
|
385 | 409 | 'data': { |
|
386 | 410 | 'text/plain': repr('z') |
|
387 | 411 | }, |
@@ -389,19 +413,19 b' def test_display_id():' | |||
|
389 | 413 | 'transient': { |
|
390 | 414 | 'display_id': handle2.display_id, |
|
391 | 415 | }, |
|
392 |
} |
|
|
416 | } | |
|
393 | 417 | |
|
394 | 418 | |
|
395 | 419 | def test_update_display(): |
|
396 | 420 | ip = get_ipython() |
|
397 | 421 | with mock.patch.object(ip.display_pub, 'publish') as pub: |
|
398 |
with |
|
|
422 | with pytest.raises(TypeError): | |
|
399 | 423 | display.update_display('x') |
|
400 | 424 | display.update_display('x', display_id='1') |
|
401 | 425 | display.update_display('y', display_id='2') |
|
402 | 426 | args, kwargs = pub.call_args_list[0] |
|
403 |
|
|
|
404 |
|
|
|
427 | assert args == () | |
|
428 | assert kwargs == { | |
|
405 | 429 | 'data': { |
|
406 | 430 | 'text/plain': repr('x') |
|
407 | 431 | }, |
@@ -410,10 +434,10 b' def test_update_display():' | |||
|
410 | 434 | 'display_id': '1', |
|
411 | 435 | }, |
|
412 | 436 | 'update': True, |
|
413 |
} |
|
|
437 | } | |
|
414 | 438 | args, kwargs = pub.call_args_list[1] |
|
415 |
|
|
|
416 |
|
|
|
439 | assert args == () | |
|
440 | assert kwargs == { | |
|
417 | 441 | 'data': { |
|
418 | 442 | 'text/plain': repr('y') |
|
419 | 443 | }, |
@@ -422,22 +446,22 b' def test_update_display():' | |||
|
422 | 446 | 'display_id': '2', |
|
423 | 447 | }, |
|
424 | 448 | 'update': True, |
|
425 |
} |
|
|
449 | } | |
|
426 | 450 | |
|
427 | 451 | |
|
428 | 452 | def test_display_handle(): |
|
429 | 453 | ip = get_ipython() |
|
430 | 454 | handle = display.DisplayHandle() |
|
431 |
|
|
|
432 |
handle = display.DisplayHandle( |
|
|
433 |
|
|
|
434 |
with mock.patch.object(ip.display_pub, |
|
|
435 |
handle.display( |
|
|
436 |
handle.update( |
|
|
455 | assert isinstance(handle.display_id, str) | |
|
456 | handle = display.DisplayHandle("my-id") | |
|
457 | assert handle.display_id == "my-id" | |
|
458 | with mock.patch.object(ip.display_pub, "publish") as pub: | |
|
459 | handle.display("x") | |
|
460 | handle.update("y") | |
|
437 | 461 | |
|
438 | 462 | args, kwargs = pub.call_args_list[0] |
|
439 |
|
|
|
440 |
|
|
|
463 | assert args == () | |
|
464 | assert kwargs == { | |
|
441 | 465 | 'data': { |
|
442 | 466 | 'text/plain': repr('x') |
|
443 | 467 | }, |
@@ -445,10 +469,10 b' def test_display_handle():' | |||
|
445 | 469 | 'transient': { |
|
446 | 470 | 'display_id': handle.display_id, |
|
447 | 471 | } |
|
448 |
} |
|
|
472 | } | |
|
449 | 473 | args, kwargs = pub.call_args_list[1] |
|
450 |
|
|
|
451 |
|
|
|
474 | assert args == () | |
|
475 | assert kwargs == { | |
|
452 | 476 | 'data': { |
|
453 | 477 | 'text/plain': repr('y') |
|
454 | 478 | }, |
@@ -457,34 +481,31 b' def test_display_handle():' | |||
|
457 | 481 | 'display_id': handle.display_id, |
|
458 | 482 | }, |
|
459 | 483 | 'update': True, |
|
460 |
} |
|
|
484 | } | |
|
461 | 485 | |
|
462 | 486 | |
|
463 | 487 | def test_image_alt_tag(): |
|
464 | 488 | """Simple test for display.Image(args, alt=x,)""" |
|
465 | 489 | thisurl = "http://example.com/image.png" |
|
466 | 490 | img = display.Image(url=thisurl, alt="an image") |
|
467 |
|
|
|
491 | assert '<img src="%s" alt="an image"/>' % (thisurl) == img._repr_html_() | |
|
468 | 492 | img = display.Image(url=thisurl, unconfined=True, alt="an image") |
|
469 |
|
|
|
470 |
|
|
|
471 |
img._repr_html_() |
|
|
493 | assert ( | |
|
494 | '<img src="%s" class="unconfined" alt="an image"/>' % (thisurl) | |
|
495 | == img._repr_html_() | |
|
472 | 496 | ) |
|
473 | 497 | img = display.Image(url=thisurl, alt='>"& <') |
|
474 | nt.assert_equal( | |
|
475 | u'<img src="%s" alt=">"& <"/>' % (thisurl), img._repr_html_() | |
|
476 | ) | |
|
498 | assert '<img src="%s" alt=">"& <"/>' % (thisurl) == img._repr_html_() | |
|
477 | 499 | |
|
478 | 500 | img = display.Image(url=thisurl, metadata={"alt": "an image"}) |
|
479 |
|
|
|
480 | ||
|
501 | assert img.alt == "an image" | |
|
481 | 502 | here = os.path.dirname(__file__) |
|
482 | 503 | img = display.Image(os.path.join(here, "2x2.png"), alt="an image") |
|
483 |
|
|
|
504 | assert img.alt == "an image" | |
|
484 | 505 | _, md = img._repr_png_() |
|
485 |
|
|
|
506 | assert md["alt"] == "an image" | |
|
486 | 507 | |
|
487 | 508 | |
|
488 | @nt.raises(FileNotFoundError) | |
|
489 | 509 | def test_image_bad_filename_raises_proper_exception(): |
|
490 | display.Image("/this/file/does/not/exist/")._repr_png_() | |
|
510 | with pytest.raises(FileNotFoundError): | |
|
511 | display.Image("/this/file/does/not/exist/")._repr_png_() |
@@ -1,6 +1,5 b'' | |||
|
1 | 1 | import unittest |
|
2 | 2 | from unittest.mock import Mock |
|
3 | import nose.tools as nt | |
|
4 | 3 | |
|
5 | 4 | from IPython.core import events |
|
6 | 5 | import IPython.testing.tools as tt |
@@ -40,9 +39,9 b' class CallbackTests(unittest.TestCase):' | |||
|
40 | 39 | def cb2(): |
|
41 | 40 | ... |
|
42 | 41 | |
|
43 |
self.em.register( |
|
|
44 |
|
|
|
45 |
self.em.unregister( |
|
|
42 | self.em.register("ping_received", cb1) | |
|
43 | self.assertRaises(ValueError, self.em.unregister, "ping_received", cb2) | |
|
44 | self.em.unregister("ping_received", cb1) | |
|
46 | 45 | |
|
47 | 46 | def test_cb_error(self): |
|
48 | 47 | cb = Mock(side_effect=ValueError) |
@@ -1,7 +1,5 b'' | |||
|
1 | 1 | import os.path |
|
2 | 2 | |
|
3 | import nose.tools as nt | |
|
4 | ||
|
5 | 3 | import IPython.testing.tools as tt |
|
6 | 4 | from IPython.utils.syspathcontext import prepended_to_syspath |
|
7 | 5 | from IPython.utils.tempdir import TemporaryDirectory |
@@ -93,4 +91,4 b' def test_extension_builtins():' | |||
|
93 | 91 | |
|
94 | 92 | def test_non_extension(): |
|
95 | 93 | em = get_ipython().extension_manager |
|
96 |
|
|
|
94 | assert em.load_extension("sys") == "no load function" |
@@ -7,7 +7,7 b' try:' | |||
|
7 | 7 | import numpy |
|
8 | 8 | except: |
|
9 | 9 | numpy = None |
|
10 | import nose.tools as nt | |
|
10 | import pytest | |
|
11 | 11 | |
|
12 | 12 | from IPython import get_ipython |
|
13 | 13 | from traitlets.config import Config |
@@ -95,24 +95,25 b' def test_bad_precision():' | |||
|
95 | 95 | """test various invalid values for float_precision.""" |
|
96 | 96 | f = PlainTextFormatter() |
|
97 | 97 | def set_fp(p): |
|
98 | f.float_precision=p | |
|
99 | nt.assert_raises(ValueError, set_fp, '%') | |
|
100 |
|
|
|
101 |
|
|
|
102 |
|
|
|
98 | f.float_precision = p | |
|
99 | ||
|
100 | pytest.raises(ValueError, set_fp, "%") | |
|
101 | pytest.raises(ValueError, set_fp, "%.3f%i") | |
|
102 | pytest.raises(ValueError, set_fp, "foo") | |
|
103 | pytest.raises(ValueError, set_fp, -1) | |
|
103 | 104 | |
|
104 | 105 | def test_for_type(): |
|
105 | 106 | f = PlainTextFormatter() |
|
106 | 107 | |
|
107 | 108 | # initial return, None |
|
108 |
|
|
|
109 | assert f.for_type(C, foo_printer) is None | |
|
109 | 110 | # no func queries |
|
110 |
|
|
|
111 | assert f.for_type(C) is foo_printer | |
|
111 | 112 | # shouldn't change anything |
|
112 |
|
|
|
113 | assert f.for_type(C) is foo_printer | |
|
113 | 114 | # None should do the same |
|
114 |
|
|
|
115 |
|
|
|
115 | assert f.for_type(C, None) is foo_printer | |
|
116 | assert f.for_type(C, None) is foo_printer | |
|
116 | 117 | |
|
117 | 118 | def test_for_type_string(): |
|
118 | 119 | f = PlainTextFormatter() |
@@ -120,13 +121,13 b' def test_for_type_string():' | |||
|
120 | 121 | type_str = '%s.%s' % (C.__module__, 'C') |
|
121 | 122 | |
|
122 | 123 | # initial return, None |
|
123 |
|
|
|
124 | assert f.for_type(type_str, foo_printer) is None | |
|
124 | 125 | # no func queries |
|
125 |
|
|
|
126 |
|
|
|
127 |
|
|
|
128 |
|
|
|
129 |
|
|
|
126 | assert f.for_type(type_str) is foo_printer | |
|
127 | assert _mod_name_key(C) in f.deferred_printers | |
|
128 | assert f.for_type(C) is foo_printer | |
|
129 | assert _mod_name_key(C) not in f.deferred_printers | |
|
130 | assert C in f.type_printers | |
|
130 | 131 | |
|
131 | 132 | def test_for_type_by_name(): |
|
132 | 133 | f = PlainTextFormatter() |
@@ -134,21 +135,22 b' def test_for_type_by_name():' | |||
|
134 | 135 | mod = C.__module__ |
|
135 | 136 | |
|
136 | 137 | # initial return, None |
|
137 |
|
|
|
138 | assert f.for_type_by_name(mod, "C", foo_printer) is None | |
|
138 | 139 | # no func queries |
|
139 |
|
|
|
140 | assert f.for_type_by_name(mod, "C") is foo_printer | |
|
140 | 141 | # shouldn't change anything |
|
141 |
|
|
|
142 | assert f.for_type_by_name(mod, "C") is foo_printer | |
|
142 | 143 | # None should do the same |
|
143 |
|
|
|
144 |
|
|
|
144 | assert f.for_type_by_name(mod, "C", None) is foo_printer | |
|
145 | assert f.for_type_by_name(mod, "C", None) is foo_printer | |
|
146 | ||
|
145 | 147 | |
|
146 | 148 | def test_lookup(): |
|
147 | 149 | f = PlainTextFormatter() |
|
148 | 150 | |
|
149 | 151 | f.for_type(C, foo_printer) |
|
150 |
|
|
|
151 |
with |
|
|
152 | assert f.lookup(C()) is foo_printer | |
|
153 | with pytest.raises(KeyError): | |
|
152 | 154 | f.lookup(A()) |
|
153 | 155 | |
|
154 | 156 | def test_lookup_string(): |
@@ -156,16 +158,16 b' def test_lookup_string():' | |||
|
156 | 158 | type_str = '%s.%s' % (C.__module__, 'C') |
|
157 | 159 | |
|
158 | 160 | f.for_type(type_str, foo_printer) |
|
159 |
|
|
|
161 | assert f.lookup(C()) is foo_printer | |
|
160 | 162 | # should move from deferred to imported dict |
|
161 |
|
|
|
162 |
|
|
|
163 | assert _mod_name_key(C) not in f.deferred_printers | |
|
164 | assert C in f.type_printers | |
|
163 | 165 | |
|
164 | 166 | def test_lookup_by_type(): |
|
165 | 167 | f = PlainTextFormatter() |
|
166 | 168 | f.for_type(C, foo_printer) |
|
167 |
|
|
|
168 |
with |
|
|
169 | assert f.lookup_by_type(C) is foo_printer | |
|
170 | with pytest.raises(KeyError): | |
|
169 | 171 | f.lookup_by_type(A) |
|
170 | 172 | |
|
171 | 173 | def test_lookup_by_type_string(): |
@@ -174,69 +176,69 b' def test_lookup_by_type_string():' | |||
|
174 | 176 | f.for_type(type_str, foo_printer) |
|
175 | 177 | |
|
176 | 178 | # verify insertion |
|
177 |
|
|
|
178 |
|
|
|
179 | assert _mod_name_key(C) in f.deferred_printers | |
|
180 | assert C not in f.type_printers | |
|
179 | 181 | |
|
180 |
|
|
|
182 | assert f.lookup_by_type(type_str) is foo_printer | |
|
181 | 183 | # lookup by string doesn't cause import |
|
182 |
|
|
|
183 |
|
|
|
184 | assert _mod_name_key(C) in f.deferred_printers | |
|
185 | assert C not in f.type_printers | |
|
184 | 186 | |
|
185 |
|
|
|
187 | assert f.lookup_by_type(C) is foo_printer | |
|
186 | 188 | # should move from deferred to imported dict |
|
187 |
|
|
|
188 |
|
|
|
189 | assert _mod_name_key(C) not in f.deferred_printers | |
|
190 | assert C in f.type_printers | |
|
189 | 191 | |
|
190 | 192 | def test_in_formatter(): |
|
191 | 193 | f = PlainTextFormatter() |
|
192 | 194 | f.for_type(C, foo_printer) |
|
193 | 195 | type_str = '%s.%s' % (C.__module__, 'C') |
|
194 |
|
|
|
195 |
|
|
|
196 | assert C in f | |
|
197 | assert type_str in f | |
|
196 | 198 | |
|
197 | 199 | def test_string_in_formatter(): |
|
198 | 200 | f = PlainTextFormatter() |
|
199 | 201 | type_str = '%s.%s' % (C.__module__, 'C') |
|
200 | 202 | f.for_type(type_str, foo_printer) |
|
201 |
|
|
|
202 |
|
|
|
203 | assert type_str in f | |
|
204 | assert C in f | |
|
203 | 205 | |
|
204 | 206 | def test_pop(): |
|
205 | 207 | f = PlainTextFormatter() |
|
206 | 208 | f.for_type(C, foo_printer) |
|
207 |
|
|
|
208 |
|
|
|
209 | assert f.lookup_by_type(C) is foo_printer | |
|
210 | assert f.pop(C, None) is foo_printer | |
|
209 | 211 | f.for_type(C, foo_printer) |
|
210 |
|
|
|
211 |
with |
|
|
212 | assert f.pop(C) is foo_printer | |
|
213 | with pytest.raises(KeyError): | |
|
212 | 214 | f.lookup_by_type(C) |
|
213 |
with |
|
|
215 | with pytest.raises(KeyError): | |
|
214 | 216 | f.pop(C) |
|
215 |
with |
|
|
217 | with pytest.raises(KeyError): | |
|
216 | 218 | f.pop(A) |
|
217 |
|
|
|
219 | assert f.pop(A, None) is None | |
|
218 | 220 | |
|
219 | 221 | def test_pop_string(): |
|
220 | 222 | f = PlainTextFormatter() |
|
221 | 223 | type_str = '%s.%s' % (C.__module__, 'C') |
|
222 | 224 | |
|
223 |
with |
|
|
225 | with pytest.raises(KeyError): | |
|
224 | 226 | f.pop(type_str) |
|
225 | 227 | |
|
226 | 228 | f.for_type(type_str, foo_printer) |
|
227 | 229 | f.pop(type_str) |
|
228 |
with |
|
|
230 | with pytest.raises(KeyError): | |
|
229 | 231 | f.lookup_by_type(C) |
|
230 |
with |
|
|
232 | with pytest.raises(KeyError): | |
|
231 | 233 | f.pop(type_str) |
|
232 | 234 | |
|
233 | 235 | f.for_type(C, foo_printer) |
|
234 |
|
|
|
235 |
with |
|
|
236 | assert f.pop(type_str, None) is foo_printer | |
|
237 | with pytest.raises(KeyError): | |
|
236 | 238 | f.lookup_by_type(C) |
|
237 |
with |
|
|
239 | with pytest.raises(KeyError): | |
|
238 | 240 | f.pop(type_str) |
|
239 |
|
|
|
241 | assert f.pop(type_str, None) is None | |
|
240 | 242 | |
|
241 | 243 | |
|
242 | 244 | def test_error_method(): |
@@ -247,10 +249,10 b' def test_error_method():' | |||
|
247 | 249 | bad = BadHTML() |
|
248 | 250 | with capture_output() as captured: |
|
249 | 251 | result = f(bad) |
|
250 |
|
|
|
251 |
|
|
|
252 |
|
|
|
253 |
|
|
|
252 | assert result is None | |
|
253 | assert "Traceback" in captured.stdout | |
|
254 | assert "Bad HTML" in captured.stdout | |
|
255 | assert "_repr_html_" in captured.stdout | |
|
254 | 256 | |
|
255 | 257 | def test_nowarn_notimplemented(): |
|
256 | 258 | f = HTMLFormatter() |
@@ -260,7 +262,7 b' def test_nowarn_notimplemented():' | |||
|
260 | 262 | h = HTMLNotImplemented() |
|
261 | 263 | with capture_output() as captured: |
|
262 | 264 | result = f(h) |
|
263 |
|
|
|
265 | assert result is None | |
|
264 | 266 | assert "" == captured.stderr |
|
265 | 267 | assert "" == captured.stdout |
|
266 | 268 | |
@@ -270,10 +272,10 b' def test_warn_error_for_type():' | |||
|
270 | 272 | f.for_type(int, lambda i: name_error) |
|
271 | 273 | with capture_output() as captured: |
|
272 | 274 | result = f(5) |
|
273 |
|
|
|
274 |
|
|
|
275 |
|
|
|
276 |
|
|
|
275 | assert result is None | |
|
276 | assert "Traceback" in captured.stdout | |
|
277 | assert "NameError" in captured.stdout | |
|
278 | assert "name_error" in captured.stdout | |
|
277 | 279 | |
|
278 | 280 | def test_error_pretty_method(): |
|
279 | 281 | f = PlainTextFormatter() |
@@ -283,11 +285,11 b' def test_error_pretty_method():' | |||
|
283 | 285 | bad = BadPretty() |
|
284 | 286 | with capture_output() as captured: |
|
285 | 287 | result = f(bad) |
|
286 |
|
|
|
287 |
|
|
|
288 |
|
|
|
289 |
|
|
|
290 |
|
|
|
288 | assert result is None | |
|
289 | assert "Traceback" in captured.stdout | |
|
290 | assert "_repr_pretty_" in captured.stdout | |
|
291 | assert "given" in captured.stdout | |
|
292 | assert "argument" in captured.stdout | |
|
291 | 293 | |
|
292 | 294 | |
|
293 | 295 | def test_bad_repr_traceback(): |
@@ -296,10 +298,10 b' def test_bad_repr_traceback():' | |||
|
296 | 298 | with capture_output() as captured: |
|
297 | 299 | result = f(bad) |
|
298 | 300 | # catches error, returns None |
|
299 |
|
|
|
300 |
|
|
|
301 |
|
|
|
302 |
|
|
|
301 | assert result is None | |
|
302 | assert "Traceback" in captured.stdout | |
|
303 | assert "__repr__" in captured.stdout | |
|
304 | assert "ValueError" in captured.stdout | |
|
303 | 305 | |
|
304 | 306 | |
|
305 | 307 | class MakePDF(object): |
@@ -319,8 +321,8 b' def test_print_method_bound():' | |||
|
319 | 321 | return "hello" |
|
320 | 322 | with capture_output() as captured: |
|
321 | 323 | result = f(MyHTML) |
|
322 |
|
|
|
323 |
|
|
|
324 | assert result is None | |
|
325 | assert "FormatterWarning" not in captured.stderr | |
|
324 | 326 | |
|
325 | 327 | with capture_output() as captured: |
|
326 | 328 | result = f(MyHTML()) |
@@ -341,8 +343,8 b' def test_print_method_weird():' | |||
|
341 | 343 | with capture_output() as captured: |
|
342 | 344 | result = f(text_hat) |
|
343 | 345 | |
|
344 |
|
|
|
345 |
|
|
|
346 | assert result is None | |
|
347 | assert "FormatterWarning" not in captured.stderr | |
|
346 | 348 | |
|
347 | 349 | class CallableMagicHat(object): |
|
348 | 350 | def __getattr__(self, key): |
@@ -362,8 +364,8 b' def test_print_method_weird():' | |||
|
362 | 364 | with capture_output() as captured: |
|
363 | 365 | result = f(bad) |
|
364 | 366 | |
|
365 |
|
|
|
366 |
|
|
|
367 | assert result is None | |
|
368 | assert "FormatterWarning" not in captured.stderr | |
|
367 | 369 | |
|
368 | 370 | |
|
369 | 371 | def test_format_config(): |
@@ -372,12 +374,12 b' def test_format_config():' | |||
|
372 | 374 | cfg = Config() |
|
373 | 375 | with capture_output() as captured: |
|
374 | 376 | result = f(cfg) |
|
375 |
|
|
|
377 | assert result is None | |
|
376 | 378 | assert captured.stderr == "" |
|
377 | 379 | |
|
378 | 380 | with capture_output() as captured: |
|
379 | 381 | result = f(Config) |
|
380 |
|
|
|
382 | assert result is None | |
|
381 | 383 | assert captured.stderr == "" |
|
382 | 384 | |
|
383 | 385 |
@@ -4,9 +4,6 b'' | |||
|
4 | 4 | # Module imports |
|
5 | 5 | #----------------------------------------------------------------------------- |
|
6 | 6 | |
|
7 | # third party | |
|
8 | import nose.tools as nt | |
|
9 | ||
|
10 | 7 | # our own packages |
|
11 | 8 | from IPython.core import autocall |
|
12 | 9 | from IPython.testing import tools as tt |
@@ -91,4 +88,4 b' def test_handlers():' | |||
|
91 | 88 | ]) |
|
92 | 89 | ip.magic('autocall 1') |
|
93 | 90 | |
|
94 |
|
|
|
91 | assert failures == [] |
@@ -13,9 +13,6 b' import tempfile' | |||
|
13 | 13 | from datetime import datetime |
|
14 | 14 | import sqlite3 |
|
15 | 15 | |
|
16 | # third party | |
|
17 | import nose.tools as nt | |
|
18 | ||
|
19 | 16 | # our own packages |
|
20 | 17 | from traitlets.config.loader import Config |
|
21 | 18 | from IPython.utils.tempdir import TemporaryDirectory |
@@ -23,7 +20,7 b' from IPython.core.history import HistoryManager, extract_hist_ranges' | |||
|
23 | 20 | from IPython.testing.decorators import skipif |
|
24 | 21 | |
|
25 | 22 | def test_proper_default_encoding(): |
|
26 |
|
|
|
23 | assert sys.getdefaultencoding() == "utf-8" | |
|
27 | 24 | |
|
28 | 25 | @skipif(sqlite3.sqlite_version_info > (3,24,0)) |
|
29 | 26 | def test_history(): |
@@ -34,7 +31,7 b' def test_history():' | |||
|
34 | 31 | hist_file = tmp_path / "history.sqlite" |
|
35 | 32 | try: |
|
36 | 33 | ip.history_manager = HistoryManager(shell=ip, hist_file=hist_file) |
|
37 |
hist = [ |
|
|
34 | hist = ["a=1", "def f():\n test = 1\n return test", "b='€Æ¾÷ß'"] | |
|
38 | 35 | for i, h in enumerate(hist, start=1): |
|
39 | 36 | ip.history_manager.store_inputs(i, h) |
|
40 | 37 | |
@@ -43,13 +40,15 b' def test_history():' | |||
|
43 | 40 | ip.history_manager.output_hist_reprs[3] = "spam" |
|
44 | 41 | ip.history_manager.store_output(3) |
|
45 | 42 | |
|
46 |
|
|
|
43 | assert ip.history_manager.input_hist_raw == [""] + hist | |
|
47 | 44 | |
|
48 | 45 | # Detailed tests for _get_range_session |
|
49 | 46 | grs = ip.history_manager._get_range_session |
|
50 |
|
|
|
51 |
|
|
|
52 | nt.assert_equal(list(grs(output=True)), list(zip([0,0,0], [1,2,3], zip(hist, [None,None,'spam'])))) | |
|
47 | assert list(grs(start=2, stop=-1)) == list(zip([0], [2], hist[1:-1])) | |
|
48 | assert list(grs(start=-2)) == list(zip([0, 0], [2, 3], hist[-2:])) | |
|
49 | assert list(grs(output=True)) == list( | |
|
50 | zip([0, 0, 0], [1, 2, 3], zip(hist, [None, None, "spam"])) | |
|
51 | ) | |
|
53 | 52 | |
|
54 | 53 | # Check whether specifying a range beyond the end of the current |
|
55 | 54 | # session results in an error (gh-804) |
@@ -63,17 +62,14 b' def test_history():' | |||
|
63 | 62 | |
|
64 | 63 | # New session |
|
65 | 64 | ip.history_manager.reset() |
|
66 | newcmds = [u"z=5", | |
|
67 | u"class X(object):\n pass", | |
|
68 | u"k='p'", | |
|
69 | u"z=5"] | |
|
65 | newcmds = ["z=5", "class X(object):\n pass", "k='p'", "z=5"] | |
|
70 | 66 | for i, cmd in enumerate(newcmds, start=1): |
|
71 | 67 | ip.history_manager.store_inputs(i, cmd) |
|
72 | 68 | gothist = ip.history_manager.get_range(start=1, stop=4) |
|
73 |
|
|
|
69 | assert list(gothist) == list(zip([0, 0, 0], [1, 2, 3], newcmds)) | |
|
74 | 70 | # Previous session: |
|
75 | 71 | gothist = ip.history_manager.get_range(-1, 1, 4) |
|
76 |
|
|
|
72 | assert list(gothist) == list(zip([1, 1, 1], [1, 2, 3], hist)) | |
|
77 | 73 | |
|
78 | 74 | newhist = [(2, i, c) for (i, c) in enumerate(newcmds, 1)] |
|
79 | 75 | |
@@ -82,62 +78,61 b' def test_history():' | |||
|
82 | 78 | include_latest=True) |
|
83 | 79 | expected = [(1, 3, (hist[-1], "spam"))] \ |
|
84 | 80 | + [(s, n, (c, None)) for (s, n, c) in newhist] |
|
85 |
|
|
|
81 | assert list(gothist) == expected | |
|
86 | 82 | |
|
87 | 83 | gothist = ip.history_manager.get_tail(2) |
|
88 | 84 | expected = newhist[-3:-1] |
|
89 |
|
|
|
85 | assert list(gothist) == expected | |
|
90 | 86 | |
|
91 | 87 | # Check get_hist_search |
|
92 | 88 | |
|
93 | 89 | gothist = ip.history_manager.search("*test*") |
|
94 |
|
|
|
90 | assert list(gothist) == [(1, 2, hist[1])] | |
|
95 | 91 | |
|
96 | 92 | gothist = ip.history_manager.search("*=*") |
|
97 |
|
|
|
98 |
|
|
|
99 |
|
|
|
100 |
|
|
|
101 |
|
|
|
102 |
|
|
|
103 |
|
|
|
93 | assert list(gothist) == [ | |
|
94 | (1, 1, hist[0]), | |
|
95 | (1, 2, hist[1]), | |
|
96 | (1, 3, hist[2]), | |
|
97 | newhist[0], | |
|
98 | newhist[2], | |
|
99 | newhist[3], | |
|
100 | ] | |
|
104 | 101 | |
|
105 | 102 | gothist = ip.history_manager.search("*=*", n=4) |
|
106 |
|
|
|
107 |
|
|
|
108 |
|
|
|
109 |
|
|
|
110 |
|
|
|
103 | assert list(gothist) == [ | |
|
104 | (1, 3, hist[2]), | |
|
105 | newhist[0], | |
|
106 | newhist[2], | |
|
107 | newhist[3], | |
|
108 | ] | |
|
111 | 109 | |
|
112 | 110 | gothist = ip.history_manager.search("*=*", unique=True) |
|
113 |
|
|
|
114 |
|
|
|
115 |
|
|
|
116 |
|
|
|
117 |
|
|
|
118 |
|
|
|
111 | assert list(gothist) == [ | |
|
112 | (1, 1, hist[0]), | |
|
113 | (1, 2, hist[1]), | |
|
114 | (1, 3, hist[2]), | |
|
115 | newhist[2], | |
|
116 | newhist[3], | |
|
117 | ] | |
|
119 | 118 | |
|
120 | 119 | gothist = ip.history_manager.search("*=*", unique=True, n=3) |
|
121 | nt.assert_equal(list(gothist), | |
|
122 | [(1, 3, hist[2]), | |
|
123 | newhist[2], | |
|
124 | newhist[3]]) | |
|
120 | assert list(gothist) == [(1, 3, hist[2]), newhist[2], newhist[3]] | |
|
125 | 121 | |
|
126 | 122 | gothist = ip.history_manager.search("b*", output=True) |
|
127 |
|
|
|
123 | assert list(gothist) == [(1, 3, (hist[2], "spam"))] | |
|
128 | 124 | |
|
129 | 125 | # Cross testing: check that magic %save can get previous session. |
|
130 | 126 | testfilename = (tmp_path / "test.py").resolve() |
|
131 | 127 | ip.magic("save " + str(testfilename) + " ~1/1-3") |
|
132 |
with io.open(testfilename, encoding= |
|
|
133 | nt.assert_equal(testfile.read(), | |
|
134 | u"# coding: utf-8\n" + u"\n".join(hist)+u"\n") | |
|
128 | with io.open(testfilename, encoding="utf-8") as testfile: | |
|
129 | assert testfile.read() == "# coding: utf-8\n" + "\n".join(hist) + "\n" | |
|
135 | 130 | |
|
136 | 131 | # Duplicate line numbers - check that it doesn't crash, and |
|
137 | 132 | # gets a new session |
|
138 | 133 | ip.history_manager.store_inputs(1, "rogue") |
|
139 | 134 | ip.history_manager.writeout_cache() |
|
140 |
|
|
|
135 | assert ip.history_manager.session_number == 3 | |
|
141 | 136 | finally: |
|
142 | 137 | # Ensure saving thread is shut down before we try to clean up the files |
|
143 | 138 | ip.history_manager.save_thread.stop() |
@@ -158,14 +153,14 b' def test_extract_hist_ranges():' | |||
|
158 | 153 | (-7, 1, 6), |
|
159 | 154 | (-10, 1, None)] |
|
160 | 155 | actual = list(extract_hist_ranges(instr)) |
|
161 |
|
|
|
156 | assert actual == expected | |
|
162 | 157 | |
|
163 | 158 | |
|
164 | 159 | def test_extract_hist_ranges_empty_str(): |
|
165 | 160 | instr = "" |
|
166 | 161 | expected = [(0, 1, None)] # 0 == current session, None == to end |
|
167 | 162 | actual = list(extract_hist_ranges(instr)) |
|
168 |
|
|
|
163 | assert actual == expected | |
|
169 | 164 | |
|
170 | 165 | |
|
171 | 166 | def test_magic_rerun(): |
@@ -173,14 +168,14 b' def test_magic_rerun():' | |||
|
173 | 168 | ip = get_ipython() |
|
174 | 169 | ip.run_cell("a = 10", store_history=True) |
|
175 | 170 | ip.run_cell("a += 1", store_history=True) |
|
176 |
|
|
|
171 | assert ip.user_ns["a"] == 11 | |
|
177 | 172 | ip.run_cell("%rerun", store_history=True) |
|
178 |
|
|
|
173 | assert ip.user_ns["a"] == 12 | |
|
179 | 174 | |
|
180 | 175 | def test_timestamp_type(): |
|
181 | 176 | ip = get_ipython() |
|
182 | 177 | info = ip.history_manager.get_session_info() |
|
183 |
|
|
|
178 | assert isinstance(info[1], datetime) | |
|
184 | 179 | |
|
185 | 180 | def test_hist_file_config(): |
|
186 | 181 | cfg = Config() |
@@ -188,7 +183,7 b' def test_hist_file_config():' | |||
|
188 | 183 | cfg.HistoryManager.hist_file = Path(tfile.name) |
|
189 | 184 | try: |
|
190 | 185 | hm = HistoryManager(shell=get_ipython(), config=cfg) |
|
191 |
|
|
|
186 | assert hm.hist_file == cfg.HistoryManager.hist_file | |
|
192 | 187 | finally: |
|
193 | 188 | try: |
|
194 | 189 | Path(tfile.name).unlink() |
@@ -210,14 +205,14 b' def test_histmanager_disabled():' | |||
|
210 | 205 | cfg.HistoryManager.hist_file = hist_file |
|
211 | 206 | try: |
|
212 | 207 | ip.history_manager = HistoryManager(shell=ip, config=cfg) |
|
213 |
hist = [ |
|
|
208 | hist = ["a=1", "def f():\n test = 1\n return test", "b='€Æ¾÷ß'"] | |
|
214 | 209 | for i, h in enumerate(hist, start=1): |
|
215 | 210 | ip.history_manager.store_inputs(i, h) |
|
216 |
|
|
|
211 | assert ip.history_manager.input_hist_raw == [""] + hist | |
|
217 | 212 | ip.history_manager.reset() |
|
218 | 213 | ip.history_manager.end_session() |
|
219 | 214 | finally: |
|
220 | 215 | ip.history_manager = hist_manager_ori |
|
221 | 216 | |
|
222 | 217 | # hist_file should not be created |
|
223 |
|
|
|
218 | assert hist_file.exists() is False |
@@ -6,7 +6,6 b'' | |||
|
6 | 6 | # Imports |
|
7 | 7 | #----------------------------------------------------------------------------- |
|
8 | 8 | |
|
9 | import nose.tools as nt | |
|
10 | 9 | from IPython.core.error import TryNext |
|
11 | 10 | from IPython.core.hooks import CommandChainDispatcher |
|
12 | 11 | |
@@ -38,27 +37,26 b' class Fail(object):' | |||
|
38 | 37 | |
|
39 | 38 | def test_command_chain_dispatcher_ff(): |
|
40 | 39 | """Test two failing hooks""" |
|
41 |
fail1 = Fail( |
|
|
42 |
fail2 = Fail( |
|
|
43 | dp = CommandChainDispatcher([(0, fail1), | |
|
44 | (10, fail2)]) | |
|
40 | fail1 = Fail("fail1") | |
|
41 | fail2 = Fail("fail2") | |
|
42 | dp = CommandChainDispatcher([(0, fail1), (10, fail2)]) | |
|
45 | 43 | |
|
46 | 44 | try: |
|
47 | 45 | dp() |
|
48 | 46 | except TryNext as e: |
|
49 |
|
|
|
47 | assert str(e) == "fail2" | |
|
50 | 48 | else: |
|
51 | 49 | assert False, "Expected exception was not raised." |
|
52 | 50 | |
|
53 |
|
|
|
54 |
|
|
|
51 | assert fail1.called is True | |
|
52 | assert fail2.called is True | |
|
55 | 53 | |
|
56 | 54 | def test_command_chain_dispatcher_fofo(): |
|
57 | 55 | """Test a mixture of failing and succeeding hooks.""" |
|
58 |
fail1 = Fail( |
|
|
59 |
fail2 = Fail( |
|
|
60 |
okay1 = Okay( |
|
|
61 |
okay2 = Okay( |
|
|
56 | fail1 = Fail("fail1") | |
|
57 | fail2 = Fail("fail2") | |
|
58 | okay1 = Okay("okay1") | |
|
59 | okay2 = Okay("okay2") | |
|
62 | 60 | |
|
63 | 61 | dp = CommandChainDispatcher([(0, fail1), |
|
64 | 62 | # (5, okay1), # add this later |
@@ -66,12 +64,12 b' def test_command_chain_dispatcher_fofo():' | |||
|
66 | 64 | (15, okay2)]) |
|
67 | 65 | dp.add(okay1, 5) |
|
68 | 66 | |
|
69 |
|
|
|
67 | assert dp() == "okay1" | |
|
70 | 68 | |
|
71 |
|
|
|
72 |
|
|
|
73 |
|
|
|
74 |
|
|
|
69 | assert fail1.called is True | |
|
70 | assert okay1.called is True | |
|
71 | assert fail2.called is False | |
|
72 | assert okay2.called is False | |
|
75 | 73 | |
|
76 | 74 | def test_command_chain_dispatcher_eq_priority(): |
|
77 | 75 | okay1 = Okay(u'okay1') |
@@ -8,8 +8,6 b'' | |||
|
8 | 8 | import unittest |
|
9 | 9 | import sys |
|
10 | 10 | |
|
11 | import nose.tools as nt | |
|
12 | ||
|
13 | 11 | from IPython.core import inputsplitter as isp |
|
14 | 12 | from IPython.core.inputtransformer import InputTransformer |
|
15 | 13 | from IPython.core.tests.test_inputtransformer import syntax, syntax_ml |
@@ -98,10 +96,10 b' def test_remove_comments():' | |||
|
98 | 96 | |
|
99 | 97 | def test_get_input_encoding(): |
|
100 | 98 | encoding = isp.get_input_encoding() |
|
101 |
|
|
|
99 | assert isinstance(encoding, str) | |
|
102 | 100 | # simple-minded check that at least encoding a simple string works with the |
|
103 | 101 | # encoding we got. |
|
104 |
|
|
|
102 | assert "test".encode(encoding) == b"test" | |
|
105 | 103 | |
|
106 | 104 | |
|
107 | 105 | class NoInputEncodingTestCase(unittest.TestCase): |
@@ -419,7 +417,7 b' class IPythonInputTestCase(InputSplitterTestCase):' | |||
|
419 | 417 | for lraw, out_t_part in line_pairs: |
|
420 | 418 | if out_t_part is not None: |
|
421 | 419 | out_t_parts.append(out_t_part) |
|
422 | ||
|
420 | ||
|
423 | 421 | if lraw is not None: |
|
424 | 422 | isp.push(lraw) |
|
425 | 423 | raw_parts.append(lraw) |
@@ -442,7 +440,7 b' class IPythonInputTestCase(InputSplitterTestCase):' | |||
|
442 | 440 | out = isp.transform_cell(raw) |
|
443 | 441 | # Match ignoring trailing whitespace |
|
444 | 442 | self.assertEqual(out.rstrip(), out_t.rstrip()) |
|
445 | ||
|
443 | ||
|
446 | 444 | def test_cellmagic_preempt(self): |
|
447 | 445 | isp = self.isp |
|
448 | 446 | for raw, name, line, cell in [ |
@@ -464,17 +462,17 b' class IPythonInputTestCase(InputSplitterTestCase):' | |||
|
464 | 462 | class CommentTransformer(InputTransformer): |
|
465 | 463 | def __init__(self): |
|
466 | 464 | self._lines = [] |
|
467 | ||
|
465 | ||
|
468 | 466 | def push(self, line): |
|
469 | 467 | self._lines.append(line + '#') |
|
470 | ||
|
468 | ||
|
471 | 469 | def reset(self): |
|
472 | 470 | text = '\n'.join(self._lines) |
|
473 | 471 | self._lines = [] |
|
474 | 472 | return text |
|
475 | ||
|
473 | ||
|
476 | 474 | isp.physical_line_transforms.insert(0, CommentTransformer()) |
|
477 | ||
|
475 | ||
|
478 | 476 | for raw, expected in [ |
|
479 | 477 | ("a=5", "a=5#"), |
|
480 | 478 | ("%ls foo", "get_ipython().run_line_magic(%r, %r)" % (u'ls', u'foo#')), |
@@ -527,38 +525,38 b" if __name__ == '__main__':" | |||
|
527 | 525 | # Tests for cell magics support |
|
528 | 526 | |
|
529 | 527 | def test_last_blank(): |
|
530 |
|
|
|
531 |
|
|
|
532 |
|
|
|
533 |
|
|
|
528 | assert isp.last_blank("") is False | |
|
529 | assert isp.last_blank("abc") is False | |
|
530 | assert isp.last_blank("abc\n") is False | |
|
531 | assert isp.last_blank("abc\na") is False | |
|
534 | 532 | |
|
535 |
|
|
|
536 |
|
|
|
537 |
|
|
|
538 |
|
|
|
539 |
|
|
|
540 |
|
|
|
541 |
|
|
|
533 | assert isp.last_blank("\n") is True | |
|
534 | assert isp.last_blank("\n ") is True | |
|
535 | assert isp.last_blank("abc\n ") is True | |
|
536 | assert isp.last_blank("abc\n\n") is True | |
|
537 | assert isp.last_blank("abc\nd\n\n") is True | |
|
538 | assert isp.last_blank("abc\nd\ne\n\n") is True | |
|
539 | assert isp.last_blank("abc \n \n \n\n") is True | |
|
542 | 540 | |
|
543 | 541 | |
|
544 | 542 | def test_last_two_blanks(): |
|
545 |
|
|
|
546 |
|
|
|
547 |
|
|
|
548 |
|
|
|
549 |
|
|
|
550 |
|
|
|
551 | ||
|
552 |
|
|
|
553 |
|
|
|
554 |
|
|
|
555 |
|
|
|
556 |
|
|
|
557 |
|
|
|
558 |
|
|
|
559 |
|
|
|
560 |
|
|
|
561 |
|
|
|
543 | assert isp.last_two_blanks("") is False | |
|
544 | assert isp.last_two_blanks("abc") is False | |
|
545 | assert isp.last_two_blanks("abc\n") is False | |
|
546 | assert isp.last_two_blanks("abc\n\na") is False | |
|
547 | assert isp.last_two_blanks("abc\n \n") is False | |
|
548 | assert isp.last_two_blanks("abc\n\n") is False | |
|
549 | ||
|
550 | assert isp.last_two_blanks("\n\n") is True | |
|
551 | assert isp.last_two_blanks("\n\n ") is True | |
|
552 | assert isp.last_two_blanks("\n \n") is True | |
|
553 | assert isp.last_two_blanks("abc\n\n ") is True | |
|
554 | assert isp.last_two_blanks("abc\n\n\n") is True | |
|
555 | assert isp.last_two_blanks("abc\n\n \n") is True | |
|
556 | assert isp.last_two_blanks("abc\n\n \n ") is True | |
|
557 | assert isp.last_two_blanks("abc\n\n \n \n") is True | |
|
558 | assert isp.last_two_blanks("abc\nd\n\n\n") is True | |
|
559 | assert isp.last_two_blanks("abc\nd\ne\nf\n\n\n") is True | |
|
562 | 560 | |
|
563 | 561 | |
|
564 | 562 | class CellMagicsCommon(object): |
@@ -567,11 +565,11 b' class CellMagicsCommon(object):' | |||
|
567 | 565 | src = "%%cellm line\nbody\n" |
|
568 | 566 | out = self.sp.transform_cell(src) |
|
569 | 567 | ref = "get_ipython().run_cell_magic('cellm', 'line', 'body')\n" |
|
570 |
|
|
|
571 | ||
|
568 | assert out == ref | |
|
569 | ||
|
572 | 570 | def test_cellmagic_help(self): |
|
573 | 571 | self.sp.push('%%cellm?') |
|
574 |
|
|
|
572 | assert self.sp.push_accepts_more() is False | |
|
575 | 573 | |
|
576 | 574 | def tearDown(self): |
|
577 | 575 | self.sp.reset() |
@@ -582,14 +580,14 b' class CellModeCellMagics(CellMagicsCommon, unittest.TestCase):' | |||
|
582 | 580 | |
|
583 | 581 | def test_incremental(self): |
|
584 | 582 | sp = self.sp |
|
585 |
sp.push( |
|
|
586 |
|
|
|
587 |
sp.push( |
|
|
588 |
|
|
|
589 |
sp.push( |
|
|
583 | sp.push("%%cellm firstline\n") | |
|
584 | assert sp.push_accepts_more() is True # 1 | |
|
585 | sp.push("line2\n") | |
|
586 | assert sp.push_accepts_more() is True # 2 | |
|
587 | sp.push("\n") | |
|
590 | 588 | # This should accept a blank line and carry on until the cell is reset |
|
591 |
|
|
|
592 | ||
|
589 | assert sp.push_accepts_more() is True # 3 | |
|
590 | ||
|
593 | 591 | def test_no_strip_coding(self): |
|
594 | 592 | src = '\n'.join([ |
|
595 | 593 | '%%writefile foo.py', |
@@ -597,7 +595,7 b' class CellModeCellMagics(CellMagicsCommon, unittest.TestCase):' | |||
|
597 | 595 | 'print(u"üñîçø∂é")', |
|
598 | 596 | ]) |
|
599 | 597 | out = self.sp.transform_cell(src) |
|
600 |
|
|
|
598 | assert "# coding: utf-8" in out | |
|
601 | 599 | |
|
602 | 600 | |
|
603 | 601 | class LineModeCellMagics(CellMagicsCommon, unittest.TestCase): |
@@ -605,11 +603,12 b' class LineModeCellMagics(CellMagicsCommon, unittest.TestCase):' | |||
|
605 | 603 | |
|
606 | 604 | def test_incremental(self): |
|
607 | 605 | sp = self.sp |
|
608 |
sp.push( |
|
|
609 |
|
|
|
610 |
sp.push( |
|
|
606 | sp.push("%%cellm line2\n") | |
|
607 | assert sp.push_accepts_more() is True # 1 | |
|
608 | sp.push("\n") | |
|
611 | 609 | # In this case, a blank line should end the cell magic |
|
612 |
|
|
|
610 | assert sp.push_accepts_more() is False # 2 | |
|
611 | ||
|
613 | 612 | |
|
614 | 613 | indentation_samples = [ |
|
615 | 614 | ('a = 1', 0), |
@@ -1,5 +1,4 b'' | |||
|
1 | 1 | import tokenize |
|
2 | import nose.tools as nt | |
|
3 | 2 | |
|
4 | 3 | from IPython.testing import tools as tt |
|
5 | 4 | |
@@ -25,7 +24,7 b' def transform_checker(tests, transformer, **kwargs):' | |||
|
25 | 24 | out = transformer.reset() |
|
26 | 25 | else: |
|
27 | 26 | out = transformer.push(inp) |
|
28 |
|
|
|
27 | assert out == tr | |
|
29 | 28 | finally: |
|
30 | 29 | transformer.reset() |
|
31 | 30 |
@@ -4,7 +4,6 b' Line-based transformers are the simpler ones; token-based transformers are' | |||
|
4 | 4 | more complex. See test_inputtransformer2_line for tests for line-based |
|
5 | 5 | transformations. |
|
6 | 6 | """ |
|
7 | import nose.tools as nt | |
|
8 | 7 | import string |
|
9 | 8 | |
|
10 | 9 | from IPython.core import inputtransformer2 as ipt2 |
@@ -147,9 +146,10 b' def check_make_token_by_line_never_ends_empty():' | |||
|
147 | 146 | """ |
|
148 | 147 | from string import printable |
|
149 | 148 | for c in printable: |
|
150 |
|
|
|
149 | assert make_tokens_by_line(c)[-1] != [] | |
|
151 | 150 | for k in printable: |
|
152 |
|
|
|
151 | assert make_tokens_by_line(c + k)[-1] != [] | |
|
152 | ||
|
153 | 153 | |
|
154 | 154 | def check_find(transformer, case, match=True): |
|
155 | 155 | sample, expected_start, _ = case |
@@ -157,21 +157,21 b' def check_find(transformer, case, match=True):' | |||
|
157 | 157 | res = transformer.find(tbl) |
|
158 | 158 | if match: |
|
159 | 159 | # start_line is stored 0-indexed, expected values are 1-indexed |
|
160 |
|
|
|
160 | assert (res.start_line + 1, res.start_col) == expected_start | |
|
161 | 161 | return res |
|
162 | 162 | else: |
|
163 |
|
|
|
163 | assert res is None | |
|
164 | 164 | |
|
165 | 165 | def check_transform(transformer_cls, case): |
|
166 | 166 | lines, start, expected = case |
|
167 | 167 | transformer = transformer_cls(start) |
|
168 |
|
|
|
168 | assert transformer.transform(lines) == expected | |
|
169 | 169 | |
|
170 | 170 | def test_continued_line(): |
|
171 | 171 | lines = MULTILINE_MAGIC_ASSIGN[0] |
|
172 |
|
|
|
172 | assert ipt2.find_end_of_continued_line(lines, 1) == 2 | |
|
173 | 173 | |
|
174 |
|
|
|
174 | assert ipt2.assemble_continued_line(lines, (1, 5), 2) == "foo bar" | |
|
175 | 175 | |
|
176 | 176 | def test_find_assign_magic(): |
|
177 | 177 | check_find(ipt2.MagicAssign, MULTILINE_MAGIC_ASSIGN) |
@@ -217,12 +217,12 b' def test_find_help():' | |||
|
217 | 217 | check_find(ipt2.HelpEnd, case) |
|
218 | 218 | |
|
219 | 219 | tf = check_find(ipt2.HelpEnd, HELP_CONTINUED_LINE) |
|
220 |
|
|
|
221 |
|
|
|
220 | assert tf.q_line == 1 | |
|
221 | assert tf.q_col == 3 | |
|
222 | 222 | |
|
223 | 223 | tf = check_find(ipt2.HelpEnd, HELP_MULTILINE) |
|
224 |
|
|
|
225 |
|
|
|
224 | assert tf.q_line == 1 | |
|
225 | assert tf.q_col == 8 | |
|
226 | 226 | |
|
227 | 227 | # ? in a comment does not trigger help |
|
228 | 228 | check_find(ipt2.HelpEnd, (["foo # bar?\n"], None, None), match=False) |
@@ -231,16 +231,16 b' def test_find_help():' | |||
|
231 | 231 | |
|
232 | 232 | def test_transform_help(): |
|
233 | 233 | tf = ipt2.HelpEnd((1, 0), (1, 9)) |
|
234 |
|
|
|
234 | assert tf.transform(HELP_IN_EXPR[0]) == HELP_IN_EXPR[2] | |
|
235 | 235 | |
|
236 | 236 | tf = ipt2.HelpEnd((1, 0), (2, 3)) |
|
237 |
|
|
|
237 | assert tf.transform(HELP_CONTINUED_LINE[0]) == HELP_CONTINUED_LINE[2] | |
|
238 | 238 | |
|
239 | 239 | tf = ipt2.HelpEnd((1, 0), (2, 8)) |
|
240 |
|
|
|
240 | assert tf.transform(HELP_MULTILINE[0]) == HELP_MULTILINE[2] | |
|
241 | 241 | |
|
242 | 242 | tf = ipt2.HelpEnd((1, 0), (1, 0)) |
|
243 |
|
|
|
243 | assert tf.transform(HELP_UNICODE[0]) == HELP_UNICODE[2] | |
|
244 | 244 | |
|
245 | 245 | def test_find_assign_op_dedent(): |
|
246 | 246 | """ |
@@ -250,31 +250,34 b' def test_find_assign_op_dedent():' | |||
|
250 | 250 | def __init__(self, s): |
|
251 | 251 | self.string = s |
|
252 | 252 | |
|
253 |
|
|
|
254 | nt.assert_equal(_find_assign_op([Tk(s) for s in ('','(', 'a','=','b', ')', '=' ,'5')]), 6) | |
|
253 | assert _find_assign_op([Tk(s) for s in ("", "a", "=", "b")]) == 2 | |
|
254 | assert ( | |
|
255 | _find_assign_op([Tk(s) for s in ("", "(", "a", "=", "b", ")", "=", "5")]) == 6 | |
|
256 | ) | |
|
257 | ||
|
255 | 258 | |
|
256 | 259 | def test_check_complete(): |
|
257 | 260 | cc = ipt2.TransformerManager().check_complete |
|
258 |
|
|
|
259 |
|
|
|
260 |
|
|
|
261 |
|
|
|
262 |
|
|
|
263 |
|
|
|
264 |
|
|
|
265 |
|
|
|
266 |
|
|
|
267 |
|
|
|
268 |
|
|
|
269 |
|
|
|
261 | assert cc("a = 1") == ("complete", None) | |
|
262 | assert cc("for a in range(5):") == ("incomplete", 4) | |
|
263 | assert cc("for a in range(5):\n if a > 0:") == ("incomplete", 8) | |
|
264 | assert cc("raise = 2") == ("invalid", None) | |
|
265 | assert cc("a = [1,\n2,") == ("incomplete", 0) | |
|
266 | assert cc("(\n))") == ("incomplete", 0) | |
|
267 | assert cc("\\\r\n") == ("incomplete", 0) | |
|
268 | assert cc("a = '''\n hi") == ("incomplete", 3) | |
|
269 | assert cc("def a():\n x=1\n global x") == ("invalid", None) | |
|
270 | assert cc("a \\ ") == ("invalid", None) # Nothing allowed after backslash | |
|
271 | assert cc("1\\\n+2") == ("complete", None) | |
|
272 | assert cc("exit") == ("complete", None) | |
|
270 | 273 | |
|
271 | 274 | example = dedent(""" |
|
272 | 275 | if True: |
|
273 | 276 | a=1""" ) |
|
274 | 277 | |
|
275 |
|
|
|
276 |
|
|
|
277 |
|
|
|
278 | assert cc(example) == ("incomplete", 4) | |
|
279 | assert cc(example + "\n") == ("complete", None) | |
|
280 | assert cc(example + "\n ") == ("complete", None) | |
|
278 | 281 | |
|
279 | 282 | # no need to loop on all the letters/numbers. |
|
280 | 283 | short = '12abAB'+string.printable[62:] |
@@ -284,7 +287,8 b' def test_check_complete():' | |||
|
284 | 287 | for k in short: |
|
285 | 288 | cc(c+k) |
|
286 | 289 | |
|
287 |
|
|
|
290 | assert cc("def f():\n x=0\n \\\n ") == ("incomplete", 2) | |
|
291 | ||
|
288 | 292 | |
|
289 | 293 | def test_check_complete_II(): |
|
290 | 294 | """ |
@@ -294,7 +298,7 b' def test_check_complete_II():' | |||
|
294 | 298 | |
|
295 | 299 | """ |
|
296 | 300 | cc = ipt2.TransformerManager().check_complete |
|
297 |
|
|
|
301 | assert cc('''def foo():\n """''') == ("incomplete", 4) | |
|
298 | 302 | |
|
299 | 303 | |
|
300 | 304 | def test_check_complete_invalidates_sunken_brackets(): |
@@ -303,22 +307,22 b' def test_check_complete_invalidates_sunken_brackets():' | |||
|
303 | 307 | interpreted as invalid |
|
304 | 308 | """ |
|
305 | 309 | cc = ipt2.TransformerManager().check_complete |
|
306 |
|
|
|
307 |
|
|
|
308 |
|
|
|
309 |
|
|
|
310 |
|
|
|
311 |
|
|
|
312 |
|
|
|
313 |
|
|
|
314 |
|
|
|
315 |
|
|
|
310 | assert cc(")") == ("invalid", None) | |
|
311 | assert cc("]") == ("invalid", None) | |
|
312 | assert cc("}") == ("invalid", None) | |
|
313 | assert cc(")(") == ("invalid", None) | |
|
314 | assert cc("][") == ("invalid", None) | |
|
315 | assert cc("}{") == ("invalid", None) | |
|
316 | assert cc("]()(") == ("invalid", None) | |
|
317 | assert cc("())(") == ("invalid", None) | |
|
318 | assert cc(")[](") == ("invalid", None) | |
|
319 | assert cc("()](") == ("invalid", None) | |
|
316 | 320 | |
|
317 | 321 | |
|
318 | 322 | def test_null_cleanup_transformer(): |
|
319 | 323 | manager = ipt2.TransformerManager() |
|
320 | 324 | manager.cleanup_transforms.insert(0, null_cleanup_transformer) |
|
321 |
assert |
|
|
325 | assert manager.transform_cell("") == "" | |
|
322 | 326 | |
|
323 | 327 | |
|
324 | 328 |
@@ -21,8 +21,6 b' from unittest import mock' | |||
|
21 | 21 | |
|
22 | 22 | from os.path import join |
|
23 | 23 | |
|
24 | import nose.tools as nt | |
|
25 | ||
|
26 | 24 | from IPython.core.error import InputRejected |
|
27 | 25 | from IPython.core.inputtransformer import InputTransformer |
|
28 | 26 | from IPython.core import interactiveshell |
@@ -220,33 +218,39 b' class InteractiveShellTestCase(unittest.TestCase):' | |||
|
220 | 218 | def test_var_expand_local(self): |
|
221 | 219 | """Test local variable expansion in !system and %magic calls""" |
|
222 | 220 | # !system |
|
223 |
ip.run_cell( |
|
|
224 | ' lvar = "ttt"\n' | |
|
225 |
|
|
|
226 | ' return ret[0]\n') | |
|
227 | res = ip.user_ns['test']() | |
|
228 | nt.assert_in('ttt', res) | |
|
229 | ||
|
221 | ip.run_cell( | |
|
222 | "def test():\n" | |
|
223 | ' lvar = "ttt"\n' | |
|
224 | " ret = !echo {lvar}\n" | |
|
225 | " return ret[0]\n" | |
|
226 | ) | |
|
227 | res = ip.user_ns["test"]() | |
|
228 | self.assertIn("ttt", res) | |
|
229 | ||
|
230 | 230 | # %magic |
|
231 |
ip.run_cell( |
|
|
232 | ' macroname = "macro_var_expand_locals"\n' | |
|
233 |
|
|
|
234 | ip.user_ns['codestr'] = "str(12)" | |
|
235 | ip.run_cell('makemacro()') | |
|
236 | nt.assert_in('macro_var_expand_locals', ip.user_ns) | |
|
237 | ||
|
231 | ip.run_cell( | |
|
232 | "def makemacro():\n" | |
|
233 | ' macroname = "macro_var_expand_locals"\n' | |
|
234 | " %macro {macroname} codestr\n" | |
|
235 | ) | |
|
236 | ip.user_ns["codestr"] = "str(12)" | |
|
237 | ip.run_cell("makemacro()") | |
|
238 | self.assertIn("macro_var_expand_locals", ip.user_ns) | |
|
239 | ||
|
238 | 240 | def test_var_expand_self(self): |
|
239 | 241 | """Test variable expansion with the name 'self', which was failing. |
|
240 | 242 | |
|
241 | 243 | See https://github.com/ipython/ipython/issues/1878#issuecomment-7698218 |
|
242 | 244 | """ |
|
243 |
ip.run_cell( |
|
|
244 | ' classvar="see me"\n' | |
|
245 | ' def test(self):\n' | |
|
246 | ' res = !echo Variable: {self.classvar}\n' | |
|
247 | ' return res[0]\n') | |
|
248 | nt.assert_in('see me', ip.user_ns['cTest']().test()) | |
|
249 | ||
|
245 | ip.run_cell( | |
|
246 | "class cTest:\n" | |
|
247 | ' classvar="see me"\n' | |
|
248 | " def test(self):\n" | |
|
249 | " res = !echo Variable: {self.classvar}\n" | |
|
250 | " return res[0]\n" | |
|
251 | ) | |
|
252 | self.assertIn("see me", ip.user_ns["cTest"]().test()) | |
|
253 | ||
|
250 | 254 | def test_bad_var_expand(self): |
|
251 | 255 | """var_expand on invalid formats shouldn't raise""" |
|
252 | 256 | # SyntaxError |
@@ -346,7 +350,7 b' class InteractiveShellTestCase(unittest.TestCase):' | |||
|
346 | 350 | info = dict(found=True, isalias=False, ismagic=True, |
|
347 | 351 | namespace = 'IPython internal', obj= lmagic.__wrapped__, |
|
348 | 352 | parent = None) |
|
349 |
|
|
|
353 | self.assertEqual(lfind, info) | |
|
350 | 354 | |
|
351 | 355 | def test_ofind_cell_magic(self): |
|
352 | 356 | from IPython.core.magic import register_cell_magic |
@@ -360,7 +364,7 b' class InteractiveShellTestCase(unittest.TestCase):' | |||
|
360 | 364 | info = dict(found=True, isalias=False, ismagic=True, |
|
361 | 365 | namespace = 'IPython internal', obj= cmagic.__wrapped__, |
|
362 | 366 | parent = None) |
|
363 |
|
|
|
367 | self.assertEqual(find, info) | |
|
364 | 368 | |
|
365 | 369 | def test_ofind_property_with_error(self): |
|
366 | 370 | class A(object): |
@@ -372,7 +376,7 b' class InteractiveShellTestCase(unittest.TestCase):' | |||
|
372 | 376 | found = ip._ofind('a.foo', [('locals', locals())]) |
|
373 | 377 | info = dict(found=True, isalias=False, ismagic=False, |
|
374 | 378 | namespace='locals', obj=A.foo, parent=a) |
|
375 |
|
|
|
379 | self.assertEqual(found, info) | |
|
376 | 380 | |
|
377 | 381 | def test_ofind_multiple_attribute_lookups(self): |
|
378 | 382 | class A(object): |
@@ -387,7 +391,7 b' class InteractiveShellTestCase(unittest.TestCase):' | |||
|
387 | 391 | found = ip._ofind('a.a.a.foo', [('locals', locals())]) |
|
388 | 392 | info = dict(found=True, isalias=False, ismagic=False, |
|
389 | 393 | namespace='locals', obj=A.foo, parent=a.a.a) |
|
390 |
|
|
|
394 | self.assertEqual(found, info) | |
|
391 | 395 | |
|
392 | 396 | def test_ofind_slotted_attributes(self): |
|
393 | 397 | class A(object): |
@@ -399,12 +403,12 b' class InteractiveShellTestCase(unittest.TestCase):' | |||
|
399 | 403 | found = ip._ofind('a.foo', [('locals', locals())]) |
|
400 | 404 | info = dict(found=True, isalias=False, ismagic=False, |
|
401 | 405 | namespace='locals', obj=a.foo, parent=a) |
|
402 |
|
|
|
406 | self.assertEqual(found, info) | |
|
403 | 407 | |
|
404 | 408 | found = ip._ofind('a.bar', [('locals', locals())]) |
|
405 | 409 | info = dict(found=False, isalias=False, ismagic=False, |
|
406 | 410 | namespace=None, obj=None, parent=a) |
|
407 |
|
|
|
411 | self.assertEqual(found, info) | |
|
408 | 412 | |
|
409 | 413 | def test_ofind_prefers_property_to_instance_level_attribute(self): |
|
410 | 414 | class A(object): |
@@ -412,10 +416,10 b' class InteractiveShellTestCase(unittest.TestCase):' | |||
|
412 | 416 | def foo(self): |
|
413 | 417 | return 'bar' |
|
414 | 418 | a = A() |
|
415 |
a.__dict__[ |
|
|
416 |
|
|
|
417 |
found = ip._ofind( |
|
|
418 |
|
|
|
419 | a.__dict__["foo"] = "baz" | |
|
420 | self.assertEqual(a.foo, "bar") | |
|
421 | found = ip._ofind("a.foo", [("locals", locals())]) | |
|
422 | self.assertIs(found["obj"], A.foo) | |
|
419 | 423 | |
|
420 | 424 | def test_custom_syntaxerror_exception(self): |
|
421 | 425 | called = [] |
@@ -819,7 +823,7 b' class TestAstTransformError(unittest.TestCase):' | |||
|
819 | 823 | ip.run_cell("1 + 2") |
|
820 | 824 | |
|
821 | 825 | # This should have been removed. |
|
822 |
|
|
|
826 | self.assertNotIn(err_transformer, ip.ast_transformers) | |
|
823 | 827 | |
|
824 | 828 | |
|
825 | 829 | class StringRejector(ast.NodeTransformer): |
@@ -889,21 +893,21 b' def test_user_variables():' | |||
|
889 | 893 | keys = {'dummy', 'doesnotexist'} |
|
890 | 894 | r = ip.user_expressions({ key:key for key in keys}) |
|
891 | 895 | |
|
892 |
|
|
|
893 |
dummy = r[ |
|
|
894 |
|
|
|
895 |
|
|
|
896 |
data = dummy[ |
|
|
897 |
metadata = dummy[ |
|
|
898 |
|
|
|
896 | assert keys == set(r.keys()) | |
|
897 | dummy = r["dummy"] | |
|
898 | assert {"status", "data", "metadata"} == set(dummy.keys()) | |
|
899 | assert dummy["status"] == "ok" | |
|
900 | data = dummy["data"] | |
|
901 | metadata = dummy["metadata"] | |
|
902 | assert data.get("text/html") == d._repr_html_() | |
|
899 | 903 | js, jsmd = d._repr_javascript_() |
|
900 |
|
|
|
901 |
|
|
|
902 | ||
|
903 |
dne = r[ |
|
|
904 |
|
|
|
905 |
|
|
|
906 | ||
|
904 | assert data.get("application/javascript") == js | |
|
905 | assert metadata.get("application/javascript") == jsmd | |
|
906 | ||
|
907 | dne = r["doesnotexist"] | |
|
908 | assert dne["status"] == "error" | |
|
909 | assert dne["ename"] == "NameError" | |
|
910 | ||
|
907 | 911 | # back to text only |
|
908 | 912 | ip.display_formatter.active_types = ['text/plain'] |
|
909 | 913 | |
@@ -917,18 +921,18 b' def test_user_expression():' | |||
|
917 | 921 | r = ip.user_expressions(query) |
|
918 | 922 | import pprint |
|
919 | 923 | pprint.pprint(r) |
|
920 |
|
|
|
921 |
a = r[ |
|
|
922 |
|
|
|
923 |
|
|
|
924 |
data = a[ |
|
|
925 |
metadata = a[ |
|
|
926 |
|
|
|
927 | ||
|
928 |
b = r[ |
|
|
929 |
|
|
|
930 |
|
|
|
931 | ||
|
924 | assert set(r.keys()) == set(query.keys()) | |
|
925 | a = r["a"] | |
|
926 | assert {"status", "data", "metadata"} == set(a.keys()) | |
|
927 | assert a["status"] == "ok" | |
|
928 | data = a["data"] | |
|
929 | metadata = a["metadata"] | |
|
930 | assert data.get("text/plain") == "3" | |
|
931 | ||
|
932 | b = r["b"] | |
|
933 | assert b["status"] == "error" | |
|
934 | assert b["ename"] == "ZeroDivisionError" | |
|
935 | ||
|
932 | 936 | # back to text only |
|
933 | 937 | ip.display_formatter.active_types = ['text/plain'] |
|
934 | 938 | |
@@ -1030,8 +1034,8 b' def test_custom_exc_count():' | |||
|
1030 | 1034 | ip.run_cell("def foo()", store_history=True) |
|
1031 | 1035 | # restore default excepthook |
|
1032 | 1036 | ip.set_custom_exc((), None) |
|
1033 |
|
|
|
1034 |
|
|
|
1037 | assert hook.call_count == 1 | |
|
1038 | assert ip.execution_count == before + 1 | |
|
1035 | 1039 | |
|
1036 | 1040 | |
|
1037 | 1041 | def test_run_cell_async(): |
@@ -17,8 +17,6 b' from pathlib import Path' | |||
|
17 | 17 | from textwrap import dedent |
|
18 | 18 | from unittest import TestCase, mock |
|
19 | 19 | |
|
20 | import nose.tools as nt | |
|
21 | ||
|
22 | 20 | import pytest |
|
23 | 21 | |
|
24 | 22 | from IPython import get_ipython |
@@ -47,18 +45,20 b' class DummyMagics(magic.Magics): pass' | |||
|
47 | 45 | |
|
48 | 46 | def test_extract_code_ranges(): |
|
49 | 47 | instr = "1 3 5-6 7-9 10:15 17: :10 10- -13 :" |
|
50 |
expected = [ |
|
|
51 |
|
|
|
52 |
|
|
|
53 |
|
|
|
54 |
|
|
|
55 |
|
|
|
56 |
|
|
|
57 |
|
|
|
58 |
|
|
|
59 |
|
|
|
48 | expected = [ | |
|
49 | (0, 1), | |
|
50 | (2, 3), | |
|
51 | (4, 6), | |
|
52 | (6, 9), | |
|
53 | (9, 14), | |
|
54 | (16, None), | |
|
55 | (None, 9), | |
|
56 | (9, None), | |
|
57 | (None, 13), | |
|
58 | (None, None), | |
|
59 | ] | |
|
60 | 60 | actual = list(code.extract_code_ranges(instr)) |
|
61 |
|
|
|
61 | assert actual == expected | |
|
62 | 62 | |
|
63 | 63 | def test_extract_symbols(): |
|
64 | 64 | source = """import foo\na = 10\ndef b():\n return 42\n\n\nclass A: pass\n\n\n""" |
@@ -70,7 +70,7 b' def test_extract_symbols():' | |||
|
70 | 70 | (["class A: pass\n"], ['a']), |
|
71 | 71 | ([], ['z'])] |
|
72 | 72 | for symbols, exp in zip(symbols_args, expected): |
|
73 |
|
|
|
73 | assert code.extract_symbols(source, symbols) == exp | |
|
74 | 74 | |
|
75 | 75 | |
|
76 | 76 | def test_extract_symbols_raises_exception_with_non_python_code(): |
@@ -78,13 +78,13 b' def test_extract_symbols_raises_exception_with_non_python_code():' | |||
|
78 | 78 | "def hello\n" |
|
79 | 79 | "puts 'Hello world'\n" |
|
80 | 80 | "end") |
|
81 |
with |
|
|
81 | with pytest.raises(SyntaxError): | |
|
82 | 82 | code.extract_symbols(source, "hello") |
|
83 | 83 | |
|
84 | 84 | |
|
85 | 85 | def test_magic_not_found(): |
|
86 | 86 | # magic not found raises UsageError |
|
87 |
with |
|
|
87 | with pytest.raises(UsageError): | |
|
88 | 88 | _ip.magic('doesntexist') |
|
89 | 89 | |
|
90 | 90 | # ensure result isn't success when a magic isn't found |
@@ -94,7 +94,7 b' def test_magic_not_found():' | |||
|
94 | 94 | |
|
95 | 95 | def test_cell_magic_not_found(): |
|
96 | 96 | # magic not found raises UsageError |
|
97 |
with |
|
|
97 | with pytest.raises(UsageError): | |
|
98 | 98 | _ip.run_cell_magic('doesntexist', 'line', 'cell') |
|
99 | 99 | |
|
100 | 100 | # ensure result isn't success when a magic isn't found |
@@ -127,7 +127,7 b' def test_config_available_configs():' | |||
|
127 | 127 | |
|
128 | 128 | stdout = captured.stdout |
|
129 | 129 | config_classes = stdout.strip().split('\n')[1:] |
|
130 |
|
|
|
130 | assert config_classes == sorted(set(config_classes)) | |
|
131 | 131 | |
|
132 | 132 | def test_config_print_class(): |
|
133 | 133 | """ test that config with a classname prints the class's options. """ |
@@ -144,19 +144,18 b' def test_rehashx():' | |||
|
144 | 144 | # clear up everything |
|
145 | 145 | _ip.alias_manager.clear_aliases() |
|
146 | 146 | del _ip.db['syscmdlist'] |
|
147 | ||
|
147 | ||
|
148 | 148 | _ip.magic('rehashx') |
|
149 | 149 | # Practically ALL ipython development systems will have more than 10 aliases |
|
150 | 150 | |
|
151 |
|
|
|
151 | assert len(_ip.alias_manager.aliases) > 10 | |
|
152 | 152 | for name, cmd in _ip.alias_manager.aliases: |
|
153 | 153 | # we must strip dots from alias names |
|
154 |
|
|
|
154 | assert "." not in name | |
|
155 | 155 | |
|
156 | 156 | # rehashx must fill up syscmdlist |
|
157 | 157 | scoms = _ip.db['syscmdlist'] |
|
158 |
|
|
|
159 | ||
|
158 | assert len(scoms) > 10 | |
|
160 | 159 | |
|
161 | 160 | |
|
162 | 161 | def test_magic_parse_options(): |
@@ -170,16 +169,17 b' def test_magic_parse_options():' | |||
|
170 | 169 | expected = 'c:x' |
|
171 | 170 | else: |
|
172 | 171 | expected = path |
|
173 |
|
|
|
172 | assert opts["f"] == expected | |
|
173 | ||
|
174 | 174 | |
|
175 | 175 | def test_magic_parse_long_options(): |
|
176 | 176 | """Magic.parse_options can handle --foo=bar long options""" |
|
177 | 177 | ip = get_ipython() |
|
178 | 178 | m = DummyMagics(ip) |
|
179 |
opts, _ = m.parse_options( |
|
|
180 |
|
|
|
181 |
|
|
|
182 |
|
|
|
179 | opts, _ = m.parse_options("--foo --bar=bubble", "a", "foo", "bar=") | |
|
180 | assert "foo" in opts | |
|
181 | assert "bar" in opts | |
|
182 | assert opts["bar"] == "bubble" | |
|
183 | 183 | |
|
184 | 184 | |
|
185 | 185 | def doctest_hist_f(): |
@@ -200,24 +200,24 b' def doctest_hist_op():' | |||
|
200 | 200 | |
|
201 | 201 | In [1]: class b(float): |
|
202 | 202 | ...: pass |
|
203 |
...: |
|
|
203 | ...: | |
|
204 | 204 | |
|
205 | 205 | In [2]: class s(object): |
|
206 | 206 | ...: def __str__(self): |
|
207 | 207 | ...: return 's' |
|
208 |
...: |
|
|
208 | ...: | |
|
209 | 209 | |
|
210 |
In [3]: |
|
|
210 | In [3]: | |
|
211 | 211 | |
|
212 | 212 | In [4]: class r(b): |
|
213 | 213 | ...: def __repr__(self): |
|
214 | 214 | ...: return 'r' |
|
215 |
...: |
|
|
215 | ...: | |
|
216 | 216 | |
|
217 | 217 | In [5]: class sr(s,r): pass |
|
218 |
...: |
|
|
218 | ...: | |
|
219 | 219 | |
|
220 |
In [6]: |
|
|
220 | In [6]: | |
|
221 | 221 | |
|
222 | 222 | In [7]: bb=b() |
|
223 | 223 | |
@@ -233,23 +233,23 b' def doctest_hist_op():' | |||
|
233 | 233 | In [12]: str(ss) |
|
234 | 234 | Out[12]: 's' |
|
235 | 235 | |
|
236 |
In [13]: |
|
|
236 | In [13]: | |
|
237 | 237 | |
|
238 | 238 | In [14]: %hist -op |
|
239 | 239 | >>> class b: |
|
240 | 240 | ... pass |
|
241 |
... |
|
|
241 | ... | |
|
242 | 242 | >>> class s(b): |
|
243 | 243 | ... def __str__(self): |
|
244 | 244 | ... return 's' |
|
245 |
... |
|
|
246 |
>>> |
|
|
245 | ... | |
|
246 | >>> | |
|
247 | 247 | >>> class r(b): |
|
248 | 248 | ... def __repr__(self): |
|
249 | 249 | ... return 'r' |
|
250 |
... |
|
|
250 | ... | |
|
251 | 251 | >>> class sr(s,r): pass |
|
252 |
>>> |
|
|
252 | >>> | |
|
253 | 253 | >>> bb=b() |
|
254 | 254 | >>> ss=s() |
|
255 | 255 | >>> rr=r() |
@@ -258,12 +258,12 b' def doctest_hist_op():' | |||
|
258 | 258 | 4.5 |
|
259 | 259 | >>> str(ss) |
|
260 | 260 | 's' |
|
261 |
>>> |
|
|
261 | >>> | |
|
262 | 262 | """ |
|
263 | 263 | |
|
264 | 264 | def test_hist_pof(): |
|
265 | 265 | ip = get_ipython() |
|
266 |
ip.run_cell( |
|
|
266 | ip.run_cell("1+2", store_history=True) | |
|
267 | 267 | #raise Exception(ip.history_manager.session_number) |
|
268 | 268 | #raise Exception(list(ip.history_manager._get_range_session())) |
|
269 | 269 | with TemporaryDirectory() as td: |
@@ -279,10 +279,10 b' def test_macro():' | |||
|
279 | 279 | for i, cmd in enumerate(cmds, start=1): |
|
280 | 280 | ip.history_manager.store_inputs(i, cmd) |
|
281 | 281 | ip.magic("macro test 1-3") |
|
282 |
|
|
|
283 | ||
|
282 | assert ip.user_ns["test"].value == "\n".join(cmds) + "\n" | |
|
283 | ||
|
284 | 284 | # List macros |
|
285 |
|
|
|
285 | assert "test" in ip.magic("macro") | |
|
286 | 286 | |
|
287 | 287 | |
|
288 | 288 | def test_macro_run(): |
@@ -292,7 +292,7 b' def test_macro_run():' | |||
|
292 | 292 | cmds = ["a=10", "a+=1", "print(a)", "%macro test 2-3"] |
|
293 | 293 | for cmd in cmds: |
|
294 | 294 | ip.run_cell(cmd, store_history=True) |
|
295 |
|
|
|
295 | assert ip.user_ns["test"].value == "a+=1\nprint(a)\n" | |
|
296 | 296 | with tt.AssertPrints("12"): |
|
297 | 297 | ip.run_cell("test") |
|
298 | 298 | with tt.AssertPrints("13"): |
@@ -304,56 +304,61 b' def test_magic_magic():' | |||
|
304 | 304 | ip = get_ipython() |
|
305 | 305 | with capture_output() as captured: |
|
306 | 306 | ip.magic("magic") |
|
307 | ||
|
307 | ||
|
308 | 308 | stdout = captured.stdout |
|
309 |
|
|
|
310 |
|
|
|
311 |
|
|
|
309 | assert "%magic" in stdout | |
|
310 | assert "IPython" in stdout | |
|
311 | assert "Available" in stdout | |
|
312 | 312 | |
|
313 | 313 | |
|
314 | 314 | @dec.skipif_not_numpy |
|
315 | 315 | def test_numpy_reset_array_undec(): |
|
316 | 316 | "Test '%reset array' functionality" |
|
317 |
_ip.ex( |
|
|
318 |
_ip.ex( |
|
|
319 |
|
|
|
320 |
_ip.magic( |
|
|
321 |
|
|
|
317 | _ip.ex("import numpy as np") | |
|
318 | _ip.ex("a = np.empty(2)") | |
|
319 | assert "a" in _ip.user_ns | |
|
320 | _ip.magic("reset -f array") | |
|
321 | assert "a" not in _ip.user_ns | |
|
322 | ||
|
322 | 323 | |
|
323 | 324 | def test_reset_out(): |
|
324 | 325 | "Test '%reset out' magic" |
|
325 | 326 | _ip.run_cell("parrot = 'dead'", store_history=True) |
|
326 | 327 | # test '%reset -f out', make an Out prompt |
|
327 | 328 | _ip.run_cell("parrot", store_history=True) |
|
328 |
|
|
|
329 |
_ip.magic( |
|
|
330 |
|
|
|
331 |
|
|
|
329 | assert "dead" in [_ip.user_ns[x] for x in ("_", "__", "___")] | |
|
330 | _ip.magic("reset -f out") | |
|
331 | assert "dead" not in [_ip.user_ns[x] for x in ("_", "__", "___")] | |
|
332 | assert len(_ip.user_ns["Out"]) == 0 | |
|
333 | ||
|
332 | 334 | |
|
333 | 335 | def test_reset_in(): |
|
334 | 336 | "Test '%reset in' magic" |
|
335 | 337 | # test '%reset -f in' |
|
336 | 338 | _ip.run_cell("parrot", store_history=True) |
|
337 |
|
|
|
338 |
_ip.magic( |
|
|
339 |
|
|
|
340 |
|
|
|
339 | assert "parrot" in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")] | |
|
340 | _ip.magic("%reset -f in") | |
|
341 | assert "parrot" not in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")] | |
|
342 | assert len(set(_ip.user_ns["In"])) == 1 | |
|
343 | ||
|
341 | 344 | |
|
342 | 345 | def test_reset_dhist(): |
|
343 | 346 | "Test '%reset dhist' magic" |
|
344 | _ip.run_cell("tmp = [d for d in _dh]") # copy before clearing | |
|
345 |
_ip.magic( |
|
|
346 |
_ip.magic( |
|
|
347 |
|
|
|
348 |
_ip.magic( |
|
|
349 |
|
|
|
350 | _ip.run_cell("_dh = [d for d in tmp]") #restore | |
|
347 | _ip.run_cell("tmp = [d for d in _dh]") # copy before clearing | |
|
348 | _ip.magic("cd " + os.path.dirname(pytest.__file__)) | |
|
349 | _ip.magic("cd -") | |
|
350 | assert len(_ip.user_ns["_dh"]) > 0 | |
|
351 | _ip.magic("reset -f dhist") | |
|
352 | assert len(_ip.user_ns["_dh"]) == 0 | |
|
353 | _ip.run_cell("_dh = [d for d in tmp]") # restore | |
|
354 | ||
|
351 | 355 | |
|
352 | 356 | def test_reset_in_length(): |
|
353 | 357 | "Test that '%reset in' preserves In[] length" |
|
354 | 358 | _ip.run_cell("print 'foo'") |
|
355 | 359 | _ip.run_cell("reset -f in") |
|
356 |
|
|
|
360 | assert len(_ip.user_ns["In"]) == _ip.displayhook.prompt_count + 1 | |
|
361 | ||
|
357 | 362 | |
|
358 | 363 | class TestResetErrors(TestCase): |
|
359 | 364 | |
@@ -384,7 +389,7 b' def test_tb_syntaxerror():' | |||
|
384 | 389 | """test %tb after a SyntaxError""" |
|
385 | 390 | ip = get_ipython() |
|
386 | 391 | ip.run_cell("for") |
|
387 | ||
|
392 | ||
|
388 | 393 | # trap and validate stdout |
|
389 | 394 | save_stdout = sys.stdout |
|
390 | 395 | try: |
@@ -395,18 +400,18 b' def test_tb_syntaxerror():' | |||
|
395 | 400 | sys.stdout = save_stdout |
|
396 | 401 | # trim output, and only check the last line |
|
397 | 402 | last_line = out.rstrip().splitlines()[-1].strip() |
|
398 |
|
|
|
403 | assert last_line == "SyntaxError: invalid syntax" | |
|
399 | 404 | |
|
400 | 405 | |
|
401 | 406 | def test_time(): |
|
402 | 407 | ip = get_ipython() |
|
403 | ||
|
408 | ||
|
404 | 409 | with tt.AssertPrints("Wall time: "): |
|
405 | 410 | ip.run_cell("%time None") |
|
406 | ||
|
411 | ||
|
407 | 412 | ip.run_cell("def f(kmjy):\n" |
|
408 | 413 | " %time print (2*kmjy)") |
|
409 | ||
|
414 | ||
|
410 | 415 | with tt.AssertPrints("Wall time: "): |
|
411 | 416 | with tt.AssertPrints("hihi", suppress=False): |
|
412 | 417 | ip.run_cell("f('hi')") |
@@ -419,12 +424,12 b' def test_time_last_not_expression():' | |||
|
419 | 424 | del ip.user_ns['var_1'] |
|
420 | 425 | assert ip.user_ns['var_2'] == 2 |
|
421 | 426 | del ip.user_ns['var_2'] |
|
422 | ||
|
427 | ||
|
423 | 428 | |
|
424 | 429 | @dec.skip_win32 |
|
425 | 430 | def test_time2(): |
|
426 | 431 | ip = get_ipython() |
|
427 | ||
|
432 | ||
|
428 | 433 | with tt.AssertPrints("CPU times: user "): |
|
429 | 434 | ip.run_cell("%time None") |
|
430 | 435 | |
@@ -432,7 +437,7 b' def test_time3():' | |||
|
432 | 437 | """Erroneous magic function calls, issue gh-3334""" |
|
433 | 438 | ip = get_ipython() |
|
434 | 439 | ip.user_ns.pop('run', None) |
|
435 | ||
|
440 | ||
|
436 | 441 | with tt.AssertNotPrints("not found", channel='stderr'): |
|
437 | 442 | ip.run_cell("%%time\n" |
|
438 | 443 | "run = 0\n" |
@@ -448,18 +453,21 b' def test_multiline_time():' | |||
|
448 | 453 | a = "ho" |
|
449 | 454 | b = "hey" |
|
450 | 455 | a+b |
|
451 |
""" |
|
|
452 | nt.assert_equal(ip.user_ns_hidden['_'], 'hohey') | |
|
456 | """ | |
|
457 | ) | |
|
458 | ) | |
|
459 | assert ip.user_ns_hidden["_"] == "hohey" | |
|
460 | ||
|
453 | 461 | |
|
454 | 462 | def test_time_local_ns(): |
|
455 | 463 | """ |
|
456 | 464 | Test that local_ns is actually global_ns when running a cell magic |
|
457 | 465 | """ |
|
458 | 466 | ip = get_ipython() |
|
459 | ip.run_cell("%%time\n" | |
|
460 | "myvar = 1") | |
|
461 |
|
|
|
462 | del ip.user_ns['myvar'] | |
|
467 | ip.run_cell("%%time\n" "myvar = 1") | |
|
468 | assert ip.user_ns["myvar"] == 1 | |
|
469 | del ip.user_ns["myvar"] | |
|
470 | ||
|
463 | 471 | |
|
464 | 472 | def test_doctest_mode(): |
|
465 | 473 | "Toggle doctest_mode twice, it should be a no-op and run without error" |
@@ -472,8 +480,8 b' def test_parse_options():' | |||
|
472 | 480 | # These are only the most minimal of tests, more should be added later. At |
|
473 | 481 | # the very least we check that basic text/unicode calls work OK. |
|
474 | 482 | m = DummyMagics(_ip) |
|
475 |
|
|
|
476 |
|
|
|
483 | assert m.parse_options("foo", "")[1] == "foo" | |
|
484 | assert m.parse_options("foo", "")[1] == "foo" | |
|
477 | 485 | |
|
478 | 486 | |
|
479 | 487 | def test_parse_options_preserve_non_option_string(): |
@@ -482,8 +490,8 b' def test_parse_options_preserve_non_option_string():' | |||
|
482 | 490 | opts, stmt = m.parse_options( |
|
483 | 491 | " -n1 -r 13 _ = 314 + foo", "n:r:", preserve_non_opts=True |
|
484 | 492 | ) |
|
485 |
|
|
|
486 |
|
|
|
493 | assert opts == {"n": "1", "r": "13"} | |
|
494 | assert stmt == "_ = 314 + foo" | |
|
487 | 495 | |
|
488 | 496 | |
|
489 | 497 | def test_run_magic_preserve_code_block(): |
@@ -501,13 +509,13 b' def test_dirops():' | |||
|
501 | 509 | ipdir = os.path.realpath(_ip.ipython_dir) |
|
502 | 510 | try: |
|
503 | 511 | _ip.magic('cd "%s"' % ipdir) |
|
504 |
|
|
|
512 | assert curpath() == ipdir | |
|
505 | 513 | _ip.magic('cd -') |
|
506 |
|
|
|
514 | assert curpath() == startdir | |
|
507 | 515 | _ip.magic('pushd "%s"' % ipdir) |
|
508 |
|
|
|
516 | assert curpath() == ipdir | |
|
509 | 517 | _ip.magic('popd') |
|
510 |
|
|
|
518 | assert curpath() == startdir | |
|
511 | 519 | finally: |
|
512 | 520 | os.chdir(startdir) |
|
513 | 521 | |
@@ -534,8 +542,8 b' def test_xmode():' | |||
|
534 | 542 | xmode = _ip.InteractiveTB.mode |
|
535 | 543 | for i in range(4): |
|
536 | 544 | _ip.magic("xmode") |
|
537 |
|
|
|
538 | ||
|
545 | assert _ip.InteractiveTB.mode == xmode | |
|
546 | ||
|
539 | 547 | def test_reset_hard(): |
|
540 | 548 | monitor = [] |
|
541 | 549 | class A(object): |
@@ -543,14 +551,14 b' def test_reset_hard():' | |||
|
543 | 551 | monitor.append(1) |
|
544 | 552 | def __repr__(self): |
|
545 | 553 | return "<A instance>" |
|
546 | ||
|
554 | ||
|
547 | 555 | _ip.user_ns["a"] = A() |
|
548 | 556 | _ip.run_cell("a") |
|
549 | ||
|
550 |
|
|
|
557 | ||
|
558 | assert monitor == [] | |
|
551 | 559 | _ip.magic("reset -f") |
|
552 |
|
|
|
553 | ||
|
560 | assert monitor == [1] | |
|
561 | ||
|
554 | 562 | class TestXdel(tt.TempFileMixin): |
|
555 | 563 | def test_xdel(self): |
|
556 | 564 | """Test that references from %run are cleared by xdel.""" |
@@ -564,36 +572,36 b' class TestXdel(tt.TempFileMixin):' | |||
|
564 | 572 | _ip.magic("run %s" % self.fname) |
|
565 | 573 | # ... as does the displayhook. |
|
566 | 574 | _ip.run_cell("a") |
|
567 | ||
|
575 | ||
|
568 | 576 | monitor = _ip.user_ns["A"].monitor |
|
569 |
|
|
|
570 | ||
|
577 | assert monitor == [] | |
|
578 | ||
|
571 | 579 | _ip.magic("xdel a") |
|
572 | ||
|
580 | ||
|
573 | 581 | # Check that a's __del__ method has been called. |
|
574 |
|
|
|
582 | assert monitor == [1] | |
|
575 | 583 | |
|
576 | 584 | def doctest_who(): |
|
577 | 585 | """doctest for %who |
|
578 | ||
|
586 | ||
|
579 | 587 | In [1]: %reset -f |
|
580 | ||
|
588 | ||
|
581 | 589 | In [2]: alpha = 123 |
|
582 | ||
|
590 | ||
|
583 | 591 | In [3]: beta = 'beta' |
|
584 | ||
|
592 | ||
|
585 | 593 | In [4]: %who int |
|
586 | 594 | alpha |
|
587 | ||
|
595 | ||
|
588 | 596 | In [5]: %who str |
|
589 | 597 | beta |
|
590 | ||
|
598 | ||
|
591 | 599 | In [6]: %whos |
|
592 | 600 | Variable Type Data/Info |
|
593 | 601 | ---------------------------- |
|
594 | 602 | alpha int 123 |
|
595 | 603 | beta str beta |
|
596 | ||
|
604 | ||
|
597 | 605 | In [7]: %who_ls |
|
598 | 606 | Out[7]: ['alpha', 'beta'] |
|
599 | 607 | """ |
@@ -608,25 +616,25 b' def test_whos():' | |||
|
608 | 616 | |
|
609 | 617 | def doctest_precision(): |
|
610 | 618 | """doctest for %precision |
|
611 | ||
|
619 | ||
|
612 | 620 | In [1]: f = get_ipython().display_formatter.formatters['text/plain'] |
|
613 | ||
|
621 | ||
|
614 | 622 | In [2]: %precision 5 |
|
615 | 623 | Out[2]: '%.5f' |
|
616 | ||
|
624 | ||
|
617 | 625 | In [3]: f.float_format |
|
618 | 626 | Out[3]: '%.5f' |
|
619 | ||
|
627 | ||
|
620 | 628 | In [4]: %precision %e |
|
621 | 629 | Out[4]: '%e' |
|
622 | ||
|
630 | ||
|
623 | 631 | In [5]: f(3.1415927) |
|
624 | 632 | Out[5]: '3.141593e+00' |
|
625 | 633 | """ |
|
626 | 634 | |
|
627 | 635 | def test_debug_magic(): |
|
628 | 636 | """Test debugging a small code with %debug |
|
629 | ||
|
637 | ||
|
630 | 638 | In [1]: with PdbTestInput(['c']): |
|
631 | 639 | ...: %debug print("a b") #doctest: +ELLIPSIS |
|
632 | 640 | ...: |
@@ -661,11 +669,12 b' def test_timeit_special_syntax():' | |||
|
661 | 669 | ip.user_ns['lmagic_out'] = line |
|
662 | 670 | |
|
663 | 671 | # line mode test |
|
664 |
_ip.run_line_magic( |
|
|
665 |
|
|
|
672 | _ip.run_line_magic("timeit", "-n1 -r1 %lmagic my line") | |
|
673 | assert _ip.user_ns["lmagic_out"] == "my line" | |
|
666 | 674 | # cell mode test |
|
667 |
_ip.run_cell_magic( |
|
|
668 |
|
|
|
675 | _ip.run_cell_magic("timeit", "-n1 -r1", "%lmagic my line2") | |
|
676 | assert _ip.user_ns["lmagic_out"] == "my line2" | |
|
677 | ||
|
669 | 678 | |
|
670 | 679 | def test_timeit_return(): |
|
671 | 680 | """ |
@@ -688,7 +697,7 b' def test_timeit_return_quiet():' | |||
|
688 | 697 | assert (res is not None) |
|
689 | 698 | |
|
690 | 699 | def test_timeit_invalid_return(): |
|
691 |
with |
|
|
700 | with pytest.raises(SyntaxError): | |
|
692 | 701 | _ip.run_line_magic('timeit', 'return') |
|
693 | 702 | |
|
694 | 703 | @dec.skipif(execution.profile is None) |
@@ -700,17 +709,19 b' def test_prun_special_syntax():' | |||
|
700 | 709 | ip.user_ns['lmagic_out'] = line |
|
701 | 710 | |
|
702 | 711 | # line mode test |
|
703 |
_ip.run_line_magic( |
|
|
704 |
|
|
|
712 | _ip.run_line_magic("prun", "-q %lmagic my line") | |
|
713 | assert _ip.user_ns["lmagic_out"] == "my line" | |
|
705 | 714 | # cell mode test |
|
706 |
_ip.run_cell_magic( |
|
|
707 |
|
|
|
715 | _ip.run_cell_magic("prun", "-q", "%lmagic my line2") | |
|
716 | assert _ip.user_ns["lmagic_out"] == "my line2" | |
|
717 | ||
|
708 | 718 | |
|
709 | 719 | @dec.skipif(execution.profile is None) |
|
710 | 720 | def test_prun_quotes(): |
|
711 | 721 | "Test that prun does not clobber string escapes (GH #1302)" |
|
712 | 722 | _ip.magic(r"prun -q x = '\t'") |
|
713 |
|
|
|
723 | assert _ip.user_ns["x"] == "\t" | |
|
724 | ||
|
714 | 725 | |
|
715 | 726 | def test_extension(): |
|
716 | 727 | # Debugging information for failures of this test |
@@ -719,14 +730,14 b' def test_extension():' | |||
|
719 | 730 | print(' ', p) |
|
720 | 731 | print('CWD', os.getcwd()) |
|
721 | 732 | |
|
722 |
|
|
|
733 | pytest.raises(ImportError, _ip.magic, "load_ext daft_extension") | |
|
723 | 734 | daft_path = os.path.join(os.path.dirname(__file__), "daft_extension") |
|
724 | 735 | sys.path.insert(0, daft_path) |
|
725 | 736 | try: |
|
726 | 737 | _ip.user_ns.pop('arq', None) |
|
727 | 738 | invalidate_caches() # Clear import caches |
|
728 | 739 | _ip.magic("load_ext daft_extension") |
|
729 |
|
|
|
740 | assert _ip.user_ns["arq"] == 185 | |
|
730 | 741 | _ip.magic("unload_ext daft_extension") |
|
731 | 742 | assert 'arq' not in _ip.user_ns |
|
732 | 743 | finally: |
@@ -736,7 +747,7 b' def test_extension():' | |||
|
736 | 747 | def test_notebook_export_json(): |
|
737 | 748 | _ip = get_ipython() |
|
738 | 749 | _ip.history_manager.reset() # Clear any existing history. |
|
739 |
cmds = [ |
|
|
750 | cmds = ["a=1", "def b():\n return a**2", "print('noël, été', b())"] | |
|
740 | 751 | for i, cmd in enumerate(cmds, start=1): |
|
741 | 752 | _ip.history_manager.store_inputs(i, cmd) |
|
742 | 753 | with TemporaryDirectory() as td: |
@@ -797,11 +808,11 b' class CellMagicTestCase(TestCase):' | |||
|
797 | 808 | |
|
798 | 809 | def check_ident(self, magic): |
|
799 | 810 | # Manually called, we get the result |
|
800 |
out = _ip.run_cell_magic(magic, |
|
|
801 | nt.assert_equal(out, ('a','b')) | |
|
811 | out = _ip.run_cell_magic(magic, "a", "b") | |
|
812 | assert out == ("a", "b") | |
|
802 | 813 | # Via run_cell, it goes into the user's namespace via displayhook |
|
803 |
_ip.run_cell( |
|
|
804 |
|
|
|
814 | _ip.run_cell("%%" + magic + " c\nd\n") | |
|
815 | assert _ip.user_ns["_"] == ("c", "d\n") | |
|
805 | 816 | |
|
806 | 817 | def test_cell_magic_func_deco(self): |
|
807 | 818 | "Cell magic using simple decorator" |
@@ -839,12 +850,12 b' class CellMagicTestCase(TestCase):' | |||
|
839 | 850 | @cell_magic('cellm4') |
|
840 | 851 | def cellm33(self, line, cell): |
|
841 | 852 | return line, cell |
|
842 | ||
|
853 | ||
|
843 | 854 | _ip.register_magics(MyMagics2) |
|
844 | 855 | self.check_ident('cellm4') |
|
845 | 856 | # Check that nothing is registered as 'cellm33' |
|
846 | 857 | c33 = _ip.find_cell_magic('cellm33') |
|
847 |
|
|
|
858 | assert c33 == None | |
|
848 | 859 | |
|
849 | 860 | def test_file(): |
|
850 | 861 | """Basic %%writefile""" |
@@ -856,8 +867,9 b' def test_file():' | |||
|
856 | 867 | 'line2', |
|
857 | 868 | ])) |
|
858 | 869 | s = Path(fname).read_text() |
|
859 |
|
|
|
860 |
|
|
|
870 | assert "line1\n" in s | |
|
871 | assert "line2" in s | |
|
872 | ||
|
861 | 873 | |
|
862 | 874 | @dec.skip_win32 |
|
863 | 875 | def test_file_single_quote(): |
@@ -870,8 +882,9 b' def test_file_single_quote():' | |||
|
870 | 882 | 'line2', |
|
871 | 883 | ])) |
|
872 | 884 | s = Path(fname).read_text() |
|
873 |
|
|
|
874 |
|
|
|
885 | assert "line1\n" in s | |
|
886 | assert "line2" in s | |
|
887 | ||
|
875 | 888 | |
|
876 | 889 | @dec.skip_win32 |
|
877 | 890 | def test_file_double_quote(): |
@@ -884,8 +897,9 b' def test_file_double_quote():' | |||
|
884 | 897 | 'line2', |
|
885 | 898 | ])) |
|
886 | 899 | s = Path(fname).read_text() |
|
887 |
|
|
|
888 |
|
|
|
900 | assert "line1\n" in s | |
|
901 | assert "line2" in s | |
|
902 | ||
|
889 | 903 | |
|
890 | 904 | def test_file_var_expand(): |
|
891 | 905 | """%%writefile $filename""" |
@@ -898,8 +912,9 b' def test_file_var_expand():' | |||
|
898 | 912 | 'line2', |
|
899 | 913 | ])) |
|
900 | 914 | s = Path(fname).read_text() |
|
901 |
|
|
|
902 |
|
|
|
915 | assert "line1\n" in s | |
|
916 | assert "line2" in s | |
|
917 | ||
|
903 | 918 | |
|
904 | 919 | def test_file_unicode(): |
|
905 | 920 | """%%writefile with unicode cell""" |
@@ -912,8 +927,9 b' def test_file_unicode():' | |||
|
912 | 927 | ])) |
|
913 | 928 | with io.open(fname, encoding='utf-8') as f: |
|
914 | 929 | s = f.read() |
|
915 |
|
|
|
916 |
|
|
|
930 | assert "liné1\n" in s | |
|
931 | assert "liné2" in s | |
|
932 | ||
|
917 | 933 | |
|
918 | 934 | def test_file_amend(): |
|
919 | 935 | """%%writefile -a amends files""" |
@@ -929,8 +945,9 b' def test_file_amend():' | |||
|
929 | 945 | 'line4', |
|
930 | 946 | ])) |
|
931 | 947 | s = Path(fname).read_text() |
|
932 |
|
|
|
933 |
|
|
|
948 | assert "line1\n" in s | |
|
949 | assert "line3\n" in s | |
|
950 | ||
|
934 | 951 | |
|
935 | 952 | def test_file_spaces(): |
|
936 | 953 | """%%file with spaces in filename""" |
@@ -942,14 +959,16 b' def test_file_spaces():' | |||
|
942 | 959 | 'line2', |
|
943 | 960 | ])) |
|
944 | 961 | s = Path(fname).read_text() |
|
945 |
|
|
|
946 |
|
|
|
947 | ||
|
962 | assert "line1\n" in s | |
|
963 | assert "line2" in s | |
|
964 | ||
|
965 | ||
|
948 | 966 | def test_script_config(): |
|
949 | 967 | ip = get_ipython() |
|
950 | 968 | ip.config.ScriptMagics.script_magics = ['whoda'] |
|
951 | 969 | sm = script.ScriptMagics(shell=ip) |
|
952 |
|
|
|
970 | assert "whoda" in sm.magics["cell"] | |
|
971 | ||
|
953 | 972 | |
|
954 | 973 | @dec.skip_iptest_but_not_pytest |
|
955 | 974 | @dec.skip_win32 |
@@ -962,7 +981,8 b' def test_script_out():' | |||
|
962 | 981 | ip = get_ipython() |
|
963 | 982 | ip.run_cell_magic("script", "--out output sh", "echo 'hi'") |
|
964 | 983 | assert asyncio.get_event_loop().is_running() is False |
|
965 |
|
|
|
984 | assert ip.user_ns["output"] == "hi\n" | |
|
985 | ||
|
966 | 986 | |
|
967 | 987 | @dec.skip_iptest_but_not_pytest |
|
968 | 988 | @dec.skip_win32 |
@@ -974,7 +994,7 b' def test_script_err():' | |||
|
974 | 994 | assert asyncio.get_event_loop().is_running() is False |
|
975 | 995 | ip.run_cell_magic("script", "--err error sh", "echo 'hello' >&2") |
|
976 | 996 | assert asyncio.get_event_loop().is_running() is False |
|
977 |
|
|
|
997 | assert ip.user_ns["error"] == "hello\n" | |
|
978 | 998 | |
|
979 | 999 | |
|
980 | 1000 | @dec.skip_iptest_but_not_pytest |
@@ -988,8 +1008,8 b' def test_script_out_err():' | |||
|
988 | 1008 | ip.run_cell_magic( |
|
989 | 1009 | "script", "--out output --err error sh", "echo 'hi'\necho 'hello' >&2" |
|
990 | 1010 | ) |
|
991 |
|
|
|
992 |
|
|
|
1011 | assert ip.user_ns["output"] == "hi\n" | |
|
1012 | assert ip.user_ns["error"] == "hello\n" | |
|
993 | 1013 | |
|
994 | 1014 | |
|
995 | 1015 | @dec.skip_iptest_but_not_pytest |
@@ -1000,10 +1020,11 b' def test_script_out_err():' | |||
|
1000 | 1020 | async def test_script_bg_out(): |
|
1001 | 1021 | ip = get_ipython() |
|
1002 | 1022 | ip.run_cell_magic("script", "--bg --out output sh", "echo 'hi'") |
|
1003 |
|
|
|
1023 | assert (await ip.user_ns["output"].read()) == b"hi\n" | |
|
1004 | 1024 | ip.user_ns["output"].close() |
|
1005 | 1025 | asyncio.get_event_loop().stop() |
|
1006 | 1026 | |
|
1027 | ||
|
1007 | 1028 | @dec.skip_iptest_but_not_pytest |
|
1008 | 1029 | @dec.skip_win32 |
|
1009 | 1030 | @pytest.mark.skipif( |
@@ -1012,7 +1033,7 b' async def test_script_bg_out():' | |||
|
1012 | 1033 | async def test_script_bg_err(): |
|
1013 | 1034 | ip = get_ipython() |
|
1014 | 1035 | ip.run_cell_magic("script", "--bg --err error sh", "echo 'hello' >&2") |
|
1015 |
|
|
|
1036 | assert (await ip.user_ns["error"].read()) == b"hello\n" | |
|
1016 | 1037 | ip.user_ns["error"].close() |
|
1017 | 1038 | |
|
1018 | 1039 | |
@@ -1026,8 +1047,8 b' async def test_script_bg_out_err():' | |||
|
1026 | 1047 | ip.run_cell_magic( |
|
1027 | 1048 | "script", "--bg --out output --err error sh", "echo 'hi'\necho 'hello' >&2" |
|
1028 | 1049 | ) |
|
1029 |
|
|
|
1030 |
|
|
|
1050 | assert (await ip.user_ns["output"].read()) == b"hi\n" | |
|
1051 | assert (await ip.user_ns["error"].read()) == b"hello\n" | |
|
1031 | 1052 | ip.user_ns["output"].close() |
|
1032 | 1053 | ip.user_ns["error"].close() |
|
1033 | 1054 | |
@@ -1040,7 +1061,7 b' def test_script_defaults():' | |||
|
1040 | 1061 | except Exception: |
|
1041 | 1062 | pass |
|
1042 | 1063 | else: |
|
1043 |
|
|
|
1064 | assert cmd in ip.magics_manager.magics["cell"] | |
|
1044 | 1065 | |
|
1045 | 1066 | |
|
1046 | 1067 | @magics_class |
@@ -1060,19 +1081,20 b' def test_line_cell_info():' | |||
|
1060 | 1081 | """%%foo and %foo magics are distinguishable to inspect""" |
|
1061 | 1082 | ip = get_ipython() |
|
1062 | 1083 | ip.magics_manager.register(FooFoo) |
|
1063 |
oinfo = ip.object_inspect( |
|
|
1064 |
|
|
|
1065 |
|
|
|
1066 | ||
|
1067 |
oinfo = ip.object_inspect( |
|
|
1068 |
|
|
|
1069 |
|
|
|
1070 |
|
|
|
1071 | ||
|
1072 |
oinfo = ip.object_inspect( |
|
|
1073 |
|
|
|
1074 |
|
|
|
1075 |
|
|
|
1084 | oinfo = ip.object_inspect("foo") | |
|
1085 | assert oinfo["found"] is True | |
|
1086 | assert oinfo["ismagic"] is True | |
|
1087 | ||
|
1088 | oinfo = ip.object_inspect("%%foo") | |
|
1089 | assert oinfo["found"] is True | |
|
1090 | assert oinfo["ismagic"] is True | |
|
1091 | assert oinfo["docstring"] == FooFoo.cell_foo.__doc__ | |
|
1092 | ||
|
1093 | oinfo = ip.object_inspect("%foo") | |
|
1094 | assert oinfo["found"] is True | |
|
1095 | assert oinfo["ismagic"] is True | |
|
1096 | assert oinfo["docstring"] == FooFoo.line_foo.__doc__ | |
|
1097 | ||
|
1076 | 1098 | |
|
1077 | 1099 | def test_multiple_magics(): |
|
1078 | 1100 | ip = get_ipython() |
@@ -1080,9 +1102,10 b' def test_multiple_magics():' | |||
|
1080 | 1102 | foo2 = FooFoo(ip) |
|
1081 | 1103 | mm = ip.magics_manager |
|
1082 | 1104 | mm.register(foo1) |
|
1083 |
|
|
|
1105 | assert mm.magics["line"]["foo"].__self__ is foo1 | |
|
1084 | 1106 | mm.register(foo2) |
|
1085 |
|
|
|
1107 | assert mm.magics["line"]["foo"].__self__ is foo2 | |
|
1108 | ||
|
1086 | 1109 | |
|
1087 | 1110 | def test_alias_magic(): |
|
1088 | 1111 | """Test %alias_magic.""" |
@@ -1090,48 +1113,49 b' def test_alias_magic():' | |||
|
1090 | 1113 | mm = ip.magics_manager |
|
1091 | 1114 | |
|
1092 | 1115 | # Basic operation: both cell and line magics are created, if possible. |
|
1093 |
ip.run_line_magic( |
|
|
1094 |
|
|
|
1095 |
|
|
|
1116 | ip.run_line_magic("alias_magic", "timeit_alias timeit") | |
|
1117 | assert "timeit_alias" in mm.magics["line"] | |
|
1118 | assert "timeit_alias" in mm.magics["cell"] | |
|
1096 | 1119 | |
|
1097 | 1120 | # --cell is specified, line magic not created. |
|
1098 |
ip.run_line_magic( |
|
|
1099 |
|
|
|
1100 |
|
|
|
1121 | ip.run_line_magic("alias_magic", "--cell timeit_cell_alias timeit") | |
|
1122 | assert "timeit_cell_alias" not in mm.magics["line"] | |
|
1123 | assert "timeit_cell_alias" in mm.magics["cell"] | |
|
1101 | 1124 | |
|
1102 | 1125 | # Test that line alias is created successfully. |
|
1103 |
ip.run_line_magic( |
|
|
1104 | nt.assert_equal(ip.run_line_magic('env', ''), | |
|
1105 | ip.run_line_magic('env_alias', '')) | |
|
1126 | ip.run_line_magic("alias_magic", "--line env_alias env") | |
|
1127 | assert ip.run_line_magic("env", "") == ip.run_line_magic("env_alias", "") | |
|
1106 | 1128 | |
|
1107 | 1129 | # Test that line alias with parameters passed in is created successfully. |
|
1108 | ip.run_line_magic('alias_magic', '--line history_alias history --params ' + shlex.quote('3')) | |
|
1109 | nt.assert_in('history_alias', mm.magics['line']) | |
|
1130 | ip.run_line_magic( | |
|
1131 | "alias_magic", "--line history_alias history --params " + shlex.quote("3") | |
|
1132 | ) | |
|
1133 | assert "history_alias" in mm.magics["line"] | |
|
1110 | 1134 | |
|
1111 | 1135 | |
|
1112 | 1136 | def test_save(): |
|
1113 | 1137 | """Test %save.""" |
|
1114 | 1138 | ip = get_ipython() |
|
1115 | 1139 | ip.history_manager.reset() # Clear any existing history. |
|
1116 |
cmds = [ |
|
|
1140 | cmds = ["a=1", "def b():\n return a**2", "print(a, b())"] | |
|
1117 | 1141 | for i, cmd in enumerate(cmds, start=1): |
|
1118 | 1142 | ip.history_manager.store_inputs(i, cmd) |
|
1119 | 1143 | with TemporaryDirectory() as tmpdir: |
|
1120 | 1144 | file = os.path.join(tmpdir, "testsave.py") |
|
1121 | 1145 | ip.run_line_magic("save", "%s 1-10" % file) |
|
1122 | 1146 | content = Path(file).read_text() |
|
1123 |
|
|
|
1124 |
|
|
|
1147 | assert content.count(cmds[0]) == 1 | |
|
1148 | assert "coding: utf-8" in content | |
|
1125 | 1149 | ip.run_line_magic("save", "-a %s 1-10" % file) |
|
1126 | 1150 | content = Path(file).read_text() |
|
1127 |
|
|
|
1128 |
|
|
|
1151 | assert content.count(cmds[0]) == 2 | |
|
1152 | assert "coding: utf-8" in content | |
|
1129 | 1153 | |
|
1130 | 1154 | |
|
1131 | 1155 | def test_save_with_no_args(): |
|
1132 | 1156 | ip = get_ipython() |
|
1133 | 1157 | ip.history_manager.reset() # Clear any existing history. |
|
1134 |
cmds = [ |
|
|
1158 | cmds = ["a=1", "def b():\n return a**2", "print(a, b())", "%save"] | |
|
1135 | 1159 | for i, cmd in enumerate(cmds, start=1): |
|
1136 | 1160 | ip.history_manager.store_inputs(i, cmd) |
|
1137 | 1161 | |
@@ -1148,26 +1172,26 b' def test_save_with_no_args():' | |||
|
1148 | 1172 | print(a, b()) |
|
1149 | 1173 | """ |
|
1150 | 1174 | ) |
|
1151 |
|
|
|
1175 | assert content == expected_content | |
|
1152 | 1176 | |
|
1153 | 1177 | |
|
1154 | 1178 | def test_store(): |
|
1155 | 1179 | """Test %store.""" |
|
1156 | 1180 | ip = get_ipython() |
|
1157 | 1181 | ip.run_line_magic('load_ext', 'storemagic') |
|
1158 | ||
|
1182 | ||
|
1159 | 1183 | # make sure the storage is empty |
|
1160 |
ip.run_line_magic( |
|
|
1161 |
ip.user_ns[ |
|
|
1162 |
ip.run_line_magic( |
|
|
1163 |
ip.user_ns[ |
|
|
1164 |
ip.run_line_magic( |
|
|
1165 |
|
|
|
1184 | ip.run_line_magic("store", "-z") | |
|
1185 | ip.user_ns["var"] = 42 | |
|
1186 | ip.run_line_magic("store", "var") | |
|
1187 | ip.user_ns["var"] = 39 | |
|
1188 | ip.run_line_magic("store", "-r") | |
|
1189 | assert ip.user_ns["var"] == 42 | |
|
1166 | 1190 | |
|
1167 |
ip.run_line_magic( |
|
|
1168 |
ip.user_ns[ |
|
|
1169 |
ip.run_line_magic( |
|
|
1170 |
|
|
|
1191 | ip.run_line_magic("store", "-d var") | |
|
1192 | ip.user_ns["var"] = 39 | |
|
1193 | ip.run_line_magic("store", "-r") | |
|
1194 | assert ip.user_ns["var"] == 39 | |
|
1171 | 1195 | |
|
1172 | 1196 | |
|
1173 | 1197 | def _run_edit_test(arg_s, exp_filename=None, |
@@ -1179,29 +1203,29 b' def _run_edit_test(arg_s, exp_filename=None,' | |||
|
1179 | 1203 | last_call = ['',''] |
|
1180 | 1204 | opts,args = M.parse_options(arg_s,'prxn:') |
|
1181 | 1205 | filename, lineno, is_temp = M._find_edit_target(ip, args, opts, last_call) |
|
1182 | ||
|
1206 | ||
|
1183 | 1207 | if exp_filename is not None: |
|
1184 |
|
|
|
1208 | assert exp_filename == filename | |
|
1185 | 1209 | if exp_contents is not None: |
|
1186 | 1210 | with io.open(filename, 'r', encoding='utf-8') as f: |
|
1187 | 1211 | contents = f.read() |
|
1188 |
|
|
|
1212 | assert exp_contents == contents | |
|
1189 | 1213 | if exp_lineno != -1: |
|
1190 |
|
|
|
1214 | assert exp_lineno == lineno | |
|
1191 | 1215 | if exp_is_temp is not None: |
|
1192 |
|
|
|
1216 | assert exp_is_temp == is_temp | |
|
1193 | 1217 | |
|
1194 | 1218 | |
|
1195 | 1219 | def test_edit_interactive(): |
|
1196 | 1220 | """%edit on interactively defined objects""" |
|
1197 | 1221 | ip = get_ipython() |
|
1198 | 1222 | n = ip.execution_count |
|
1199 |
ip.run_cell( |
|
|
1200 | ||
|
1223 | ip.run_cell("def foo(): return 1", store_history=True) | |
|
1224 | ||
|
1201 | 1225 | try: |
|
1202 | 1226 | _run_edit_test("foo") |
|
1203 | 1227 | except code.InteractivelyDefined as e: |
|
1204 |
|
|
|
1228 | assert e.index == n | |
|
1205 | 1229 | else: |
|
1206 | 1230 | raise AssertionError("Should have raised InteractivelyDefined") |
|
1207 | 1231 | |
@@ -1209,9 +1233,9 b' def test_edit_interactive():' | |||
|
1209 | 1233 | def test_edit_cell(): |
|
1210 | 1234 | """%edit [cell id]""" |
|
1211 | 1235 | ip = get_ipython() |
|
1212 | ||
|
1213 |
ip.run_cell( |
|
|
1214 | ||
|
1236 | ||
|
1237 | ip.run_cell("def foo(): return 1", store_history=True) | |
|
1238 | ||
|
1215 | 1239 | # test |
|
1216 | 1240 | _run_edit_test("1", exp_contents=ip.user_ns['In'][1], exp_is_temp=True) |
|
1217 | 1241 | |
@@ -1234,17 +1258,18 b' def test_ls_magic():' | |||
|
1234 | 1258 | lsmagic = ip.magic('lsmagic') |
|
1235 | 1259 | with warnings.catch_warnings(record=True) as w: |
|
1236 | 1260 | j = json_formatter(lsmagic) |
|
1237 |
|
|
|
1238 |
|
|
|
1261 | assert sorted(j) == ["cell", "line"] | |
|
1262 | assert w == [] # no warnings | |
|
1263 | ||
|
1239 | 1264 | |
|
1240 | 1265 | def test_strip_initial_indent(): |
|
1241 | 1266 | def sii(s): |
|
1242 | 1267 | lines = s.splitlines() |
|
1243 | 1268 | return '\n'.join(code.strip_initial_indent(lines)) |
|
1244 | 1269 | |
|
1245 |
|
|
|
1246 |
|
|
|
1247 |
|
|
|
1270 | assert sii(" a = 1\nb = 2") == "a = 1\nb = 2" | |
|
1271 | assert sii(" a\n b\nc") == "a\n b\nc" | |
|
1272 | assert sii("a\n b") == "a\n b" | |
|
1248 | 1273 | |
|
1249 | 1274 | def test_logging_magic_quiet_from_arg(): |
|
1250 | 1275 | _ip.config.LoggingMagics.quiet = False |
@@ -1336,6 +1361,6 b' def test_run_module_from_import_hook():' | |||
|
1336 | 1361 | _ip.run_cell("import my_tmp") |
|
1337 | 1362 | |
|
1338 | 1363 | output = "Loaded my_tmp\nI just ran a script\nLoaded my_tmp\n" |
|
1339 |
|
|
|
1364 | assert output == captured.stdout | |
|
1340 | 1365 | |
|
1341 | 1366 | sys.meta_path.pop(0) |
@@ -11,8 +11,6 b' import sys' | |||
|
11 | 11 | from io import StringIO |
|
12 | 12 | from unittest import TestCase |
|
13 | 13 | |
|
14 | import nose.tools as nt | |
|
15 | ||
|
16 | 14 | from IPython.testing import tools as tt |
|
17 | 15 | |
|
18 | 16 | #----------------------------------------------------------------------------- |
@@ -93,16 +91,16 b' class PasteTestCase(TestCase):' | |||
|
93 | 91 | ip.hooks.clipboard_get = self.original_clip |
|
94 | 92 | |
|
95 | 93 | def test_paste(self): |
|
96 |
ip.user_ns.pop( |
|
|
97 |
self.paste( |
|
|
98 |
|
|
|
99 |
ip.user_ns.pop( |
|
|
94 | ip.user_ns.pop("x", None) | |
|
95 | self.paste("x = 1") | |
|
96 | self.assertEqual(ip.user_ns["x"], 1) | |
|
97 | ip.user_ns.pop("x") | |
|
100 | 98 | |
|
101 | 99 | def test_paste_pyprompt(self): |
|
102 |
ip.user_ns.pop( |
|
|
103 |
self.paste( |
|
|
104 |
|
|
|
105 |
ip.user_ns.pop( |
|
|
100 | ip.user_ns.pop("x", None) | |
|
101 | self.paste(">>> x=2") | |
|
102 | self.assertEqual(ip.user_ns["x"], 2) | |
|
103 | ip.user_ns.pop("x") | |
|
106 | 104 | |
|
107 | 105 | def test_paste_py_multi(self): |
|
108 | 106 | self.paste(""" |
@@ -111,35 +109,38 b' class PasteTestCase(TestCase):' | |||
|
111 | 109 | >>> for i in x: |
|
112 | 110 | ... y.append(i**2) |
|
113 | 111 | ... |
|
114 |
""" |
|
|
115 | nt.assert_equal(ip.user_ns['x'], [1,2,3]) | |
|
116 |
|
|
|
112 | """ | |
|
113 | ) | |
|
114 | self.assertEqual(ip.user_ns["x"], [1, 2, 3]) | |
|
115 | self.assertEqual(ip.user_ns["y"], [1, 4, 9]) | |
|
117 | 116 | |
|
118 | 117 | def test_paste_py_multi_r(self): |
|
119 | 118 | "Now, test that self.paste -r works" |
|
120 | 119 | self.test_paste_py_multi() |
|
121 |
|
|
|
122 |
|
|
|
123 |
|
|
|
124 |
ip.magic( |
|
|
125 |
|
|
|
126 |
|
|
|
120 | self.assertEqual(ip.user_ns.pop("x"), [1, 2, 3]) | |
|
121 | self.assertEqual(ip.user_ns.pop("y"), [1, 4, 9]) | |
|
122 | self.assertFalse("x" in ip.user_ns) | |
|
123 | ip.magic("paste -r") | |
|
124 | self.assertEqual(ip.user_ns["x"], [1, 2, 3]) | |
|
125 | self.assertEqual(ip.user_ns["y"], [1, 4, 9]) | |
|
127 | 126 | |
|
128 | 127 | def test_paste_email(self): |
|
129 | 128 | "Test pasting of email-quoted contents" |
|
130 | 129 | self.paste("""\ |
|
131 | 130 | >> def foo(x): |
|
132 | 131 | >> return x + 1 |
|
133 |
>> xx = foo(1.1)""" |
|
|
134 | nt.assert_equal(ip.user_ns['xx'], 2.1) | |
|
132 | >> xx = foo(1.1)""" | |
|
133 | ) | |
|
134 | self.assertEqual(ip.user_ns["xx"], 2.1) | |
|
135 | 135 | |
|
136 | 136 | def test_paste_email2(self): |
|
137 | 137 | "Email again; some programs add a space also at each quoting level" |
|
138 | 138 | self.paste("""\ |
|
139 | 139 | > > def foo(x): |
|
140 | 140 | > > return x + 1 |
|
141 |
> > yy = foo(2.1) """ |
|
|
142 | nt.assert_equal(ip.user_ns['yy'], 3.1) | |
|
141 | > > yy = foo(2.1) """ | |
|
142 | ) | |
|
143 | self.assertEqual(ip.user_ns["yy"], 3.1) | |
|
143 | 144 | |
|
144 | 145 | def test_paste_email_py(self): |
|
145 | 146 | "Email quoting of interactive input" |
@@ -147,8 +148,9 b' class PasteTestCase(TestCase):' | |||
|
147 | 148 | >> >>> def f(x): |
|
148 | 149 | >> ... return x+1 |
|
149 | 150 | >> ... |
|
150 |
>> >>> zz = f(2.5) """ |
|
|
151 | nt.assert_equal(ip.user_ns['zz'], 3.5) | |
|
151 | >> >>> zz = f(2.5) """ | |
|
152 | ) | |
|
153 | self.assertEqual(ip.user_ns["zz"], 3.5) | |
|
152 | 154 | |
|
153 | 155 | def test_paste_echo(self): |
|
154 | 156 | "Also test self.paste echoing, by temporarily faking the writer" |
@@ -163,9 +165,9 b' class PasteTestCase(TestCase):' | |||
|
163 | 165 | out = w.getvalue() |
|
164 | 166 | finally: |
|
165 | 167 | ip.write = writer |
|
166 |
|
|
|
167 |
|
|
|
168 | assert out == code+"\n## -- End pasted text --\n" | |
|
168 | self.assertEqual(ip.user_ns["a"], 100) | |
|
169 | self.assertEqual(ip.user_ns["b"], 200) | |
|
170 | assert out == code + "\n## -- End pasted text --\n" | |
|
169 | 171 | |
|
170 | 172 | def test_paste_leading_commas(self): |
|
171 | 173 | "Test multiline strings with leading commas" |
@@ -174,10 +176,9 b' class PasteTestCase(TestCase):' | |||
|
174 | 176 | a = """ |
|
175 | 177 | ,1,2,3 |
|
176 | 178 | """''' |
|
177 |
ip.user_ns.pop( |
|
|
178 |
tm.store_or_execute(s, |
|
|
179 |
|
|
|
180 | ||
|
179 | ip.user_ns.pop("foo", None) | |
|
180 | tm.store_or_execute(s, "foo") | |
|
181 | self.assertIn("foo", ip.user_ns) | |
|
181 | 182 | |
|
182 | 183 | def test_paste_trailing_question(self): |
|
183 | 184 | "Test pasting sources with trailing question marks" |
@@ -189,4 +190,4 b' def funcfoo():' | |||
|
189 | 190 | ''' |
|
190 | 191 | ip.user_ns.pop('funcfoo', None) |
|
191 | 192 | self.paste(s) |
|
192 |
|
|
|
193 | self.assertEqual(ip.user_ns["funcfoo"](), "fooresult") |
@@ -9,8 +9,6 b' from inspect import signature, Signature, Parameter' | |||
|
9 | 9 | import os |
|
10 | 10 | import re |
|
11 | 11 | |
|
12 | import nose.tools as nt | |
|
13 | ||
|
14 | 12 | from .. import oinspect |
|
15 | 13 | |
|
16 | 14 | from decorator import decorator |
@@ -38,7 +36,7 b' def setup_module():' | |||
|
38 | 36 | # defined, if any code is inserted above, the following line will need to be |
|
39 | 37 | # updated. Do NOT insert any whitespace between the next line and the function |
|
40 | 38 | # definition below. |
|
41 |
THIS_LINE_NUMBER = |
|
|
39 | THIS_LINE_NUMBER = 39 # Put here the actual number of this line | |
|
42 | 40 | |
|
43 | 41 | from unittest import TestCase |
|
44 | 42 | |
@@ -74,7 +72,7 b' def test_find_file_decorated1():' | |||
|
74 | 72 | @noop1 |
|
75 | 73 | def f(x): |
|
76 | 74 | "My docstring" |
|
77 | ||
|
75 | ||
|
78 | 76 | match_pyfiles(oinspect.find_file(f), os.path.abspath(__file__)) |
|
79 | 77 | assert f.__doc__ == "My docstring" |
|
80 | 78 | |
@@ -90,14 +88,14 b' def test_find_file_decorated2():' | |||
|
90 | 88 | @noop2 |
|
91 | 89 | def f(x): |
|
92 | 90 | "My docstring 2" |
|
93 | ||
|
91 | ||
|
94 | 92 | match_pyfiles(oinspect.find_file(f), os.path.abspath(__file__)) |
|
95 | 93 | assert f.__doc__ == "My docstring 2" |
|
96 | ||
|
94 | ||
|
97 | 95 | |
|
98 | 96 | def test_find_file_magic(): |
|
99 | 97 | run = ip.find_line_magic('run') |
|
100 |
|
|
|
98 | assert oinspect.find_file(run) is not None | |
|
101 | 99 | |
|
102 | 100 | |
|
103 | 101 | # A few generic objects we can then inspect in the tests below |
@@ -169,11 +167,11 b' def test_info():' | |||
|
169 | 167 | "Check that Inspector.info fills out various fields as expected." |
|
170 | 168 | i = inspector.info(Call, oname="Call") |
|
171 | 169 | assert i["type_name"] == "type" |
|
172 | expted_class = str(type(type)) # <class 'type'> (Python 3) or <type 'type'> | |
|
173 | assert i["base_class"] == expted_class | |
|
174 |
|
|
|
175 | i["string_form"], | |
|
170 | expected_class = str(type(type)) # <class 'type'> (Python 3) or <type 'type'> | |
|
171 | assert i["base_class"] == expected_class | |
|
172 | assert re.search( | |
|
176 | 173 | "<class 'IPython.core.tests.test_oinspect.Call'( at 0x[0-9a-f]{1,9})?>", |
|
174 | i["string_form"], | |
|
177 | 175 | ) |
|
178 | 176 | fname = __file__ |
|
179 | 177 | if fname.endswith(".pyc"): |
@@ -184,12 +182,12 b' def test_info():' | |||
|
184 | 182 | assert i["definition"] == None |
|
185 | 183 | assert i["docstring"] == Call.__doc__ |
|
186 | 184 | assert i["source"] == None |
|
187 |
|
|
|
185 | assert i["isclass"] is True | |
|
188 | 186 | assert i["init_definition"] == "Call(x, y=1)" |
|
189 | 187 | assert i["init_docstring"] == Call.__init__.__doc__ |
|
190 | 188 | |
|
191 | 189 | i = inspector.info(Call, detail_level=1) |
|
192 |
|
|
|
190 | assert i["source"] is not None | |
|
193 | 191 | assert i["docstring"] == None |
|
194 | 192 | |
|
195 | 193 | c = Call(1) |
@@ -221,7 +219,7 b' def test_info_serialliar():' | |||
|
221 | 219 | |
|
222 | 220 | # Nested attribute access should be cut off at 100 levels deep to avoid |
|
223 | 221 | # infinite loops: https://github.com/ipython/ipython/issues/9122 |
|
224 |
|
|
|
222 | assert fib_tracker[0] < 9000 | |
|
225 | 223 | |
|
226 | 224 | def support_function_one(x, y=2, *a, **kw): |
|
227 | 225 | """A simple function.""" |
@@ -230,7 +228,8 b' def test_calldef_none():' | |||
|
230 | 228 | # We should ignore __call__ for all of these. |
|
231 | 229 | for obj in [support_function_one, SimpleClass().method, any, str.upper]: |
|
232 | 230 | i = inspector.info(obj) |
|
233 |
|
|
|
231 | assert i["call_def"] is None | |
|
232 | ||
|
234 | 233 | |
|
235 | 234 | def f_kwarg(pos, *, kwonly): |
|
236 | 235 | pass |
@@ -249,16 +248,16 b' def test_getdoc():' | |||
|
249 | 248 | """standard docstring""" |
|
250 | 249 | def getdoc(self): |
|
251 | 250 | return "custom docstring" |
|
252 | ||
|
251 | ||
|
253 | 252 | class C(object): |
|
254 | 253 | """standard docstring""" |
|
255 | 254 | def getdoc(self): |
|
256 | 255 | return None |
|
257 | ||
|
256 | ||
|
258 | 257 | a = A() |
|
259 | 258 | b = B() |
|
260 | 259 | c = C() |
|
261 | ||
|
260 | ||
|
262 | 261 | assert oinspect.getdoc(a) == "standard docstring" |
|
263 | 262 | assert oinspect.getdoc(b) == "custom docstring" |
|
264 | 263 | assert oinspect.getdoc(c) == "standard docstring" |
@@ -266,17 +265,17 b' def test_getdoc():' | |||
|
266 | 265 | |
|
267 | 266 | def test_empty_property_has_no_source(): |
|
268 | 267 | i = inspector.info(property(), detail_level=1) |
|
269 |
|
|
|
268 | assert i["source"] is None | |
|
270 | 269 | |
|
271 | 270 | |
|
272 | 271 | def test_property_sources(): |
|
273 |
import posixpath |
|
|
272 | import posixpath | |
|
274 | 273 | # A simple adder whose source and signature stays |
|
275 | 274 | # the same across Python distributions |
|
276 | 275 | def simple_add(a, b): |
|
277 | 276 | "Adds two numbers" |
|
278 | 277 | return a + b |
|
279 | ||
|
278 | ||
|
280 | 279 | class A(object): |
|
281 | 280 | @property |
|
282 | 281 | def foo(self): |
@@ -285,17 +284,17 b' def test_property_sources():' | |||
|
285 | 284 | foo = foo.setter(lambda self, v: setattr(self, 'bar', v)) |
|
286 | 285 | |
|
287 | 286 | dname = property(posixpath.dirname) |
|
288 |
adder = property(simple_add) |
|
|
287 | adder = property(simple_add) | |
|
289 | 288 | |
|
290 | 289 | i = inspector.info(A.foo, detail_level=1) |
|
291 |
|
|
|
292 |
|
|
|
290 | assert "def foo(self):" in i["source"] | |
|
291 | assert "lambda self, v:" in i["source"] | |
|
293 | 292 | |
|
294 | 293 | i = inspector.info(A.dname, detail_level=1) |
|
295 |
|
|
|
296 | ||
|
294 | assert "def dirname(p)" in i["source"] | |
|
295 | ||
|
297 | 296 | i = inspector.info(A.adder, detail_level=1) |
|
298 |
|
|
|
297 | assert "def simple_add(a, b)" in i["source"] | |
|
299 | 298 | |
|
300 | 299 | |
|
301 | 300 | def test_property_docstring_is_in_info_for_detail_level_0(): |
@@ -367,11 +366,11 b' def test_pinfo_docstring_if_detail_and_no_source():' | |||
|
367 | 366 | def bar(self): |
|
368 | 367 | """ This is a docstring for Foo.bar """ |
|
369 | 368 | pass |
|
370 |
''' |
|
|
371 | ||
|
369 | ''' | |
|
370 | ||
|
372 | 371 | ip.run_cell(obj_def) |
|
373 | 372 | ip.run_cell('foo = Foo()') |
|
374 | ||
|
373 | ||
|
375 | 374 | with AssertNotPrints("Source:"): |
|
376 | 375 | with AssertPrints('Docstring:'): |
|
377 | 376 | ip._inspect('pinfo', 'foo', detail_level=0) |
@@ -396,14 +395,14 b' def test_pinfo_magic():' | |||
|
396 | 395 | def test_init_colors(): |
|
397 | 396 | # ensure colors are not present in signature info |
|
398 | 397 | info = inspector.info(HasSignature) |
|
399 |
init_def = info[ |
|
|
400 |
|
|
|
398 | init_def = info["init_definition"] | |
|
399 | assert "[0m" not in init_def | |
|
401 | 400 | |
|
402 | 401 | |
|
403 | 402 | def test_builtin_init(): |
|
404 | 403 | info = inspector.info(list) |
|
405 | 404 | init_def = info['init_definition'] |
|
406 | nt.assert_is_not_none(init_def) | |
|
405 | assert init_def is not None | |
|
407 | 406 | |
|
408 | 407 | |
|
409 | 408 | def test_render_signature_short(): |
@@ -428,7 +427,7 b' def test_render_signature_long():' | |||
|
428 | 427 | signature(long_function), |
|
429 | 428 | long_function.__name__, |
|
430 | 429 | ) |
|
431 |
|
|
|
430 | assert sig in [ | |
|
432 | 431 | # Python >=3.9 |
|
433 | 432 | '''\ |
|
434 | 433 | long_function( |
@@ -452,4 +451,4 b' long_function(' | |||
|
452 | 451 | let_us_make_sure_this_is_looong:Union[str, NoneType]=None, |
|
453 | 452 | ) -> bool\ |
|
454 | 453 | ''', |
|
455 |
] |
|
|
454 | ] |
@@ -6,7 +6,6 b' import tempfile' | |||
|
6 | 6 | import warnings |
|
7 | 7 | from unittest.mock import patch |
|
8 | 8 | |
|
9 | import nose.tools as nt | |
|
10 | 9 | from testpath import modified_env, assert_isdir, assert_isfile |
|
11 | 10 | |
|
12 | 11 | from IPython import paths |
@@ -52,7 +51,7 b' def test_get_ipython_dir_1():' | |||
|
52 | 51 | modified_env({'IPYTHONDIR': env_ipdir}): |
|
53 | 52 | ipdir = paths.get_ipython_dir() |
|
54 | 53 | |
|
55 |
|
|
|
54 | assert ipdir == env_ipdir | |
|
56 | 55 | |
|
57 | 56 | def test_get_ipython_dir_2(): |
|
58 | 57 | """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions.""" |
@@ -66,7 +65,7 b' def test_get_ipython_dir_2():' | |||
|
66 | 65 | }): |
|
67 | 66 | ipdir = paths.get_ipython_dir() |
|
68 | 67 | |
|
69 |
|
|
|
68 | assert ipdir == os.path.join("someplace", ".ipython") | |
|
70 | 69 | |
|
71 | 70 | def test_get_ipython_dir_3(): |
|
72 | 71 | """test_get_ipython_dir_3, move XDG if defined, and .ipython doesn't exist.""" |
@@ -81,10 +80,10 b' def test_get_ipython_dir_3():' | |||
|
81 | 80 | }), warnings.catch_warnings(record=True) as w: |
|
82 | 81 | ipdir = paths.get_ipython_dir() |
|
83 | 82 | |
|
84 |
|
|
|
83 | assert ipdir == os.path.join(tmphome.name, ".ipython") | |
|
85 | 84 | if sys.platform != 'darwin': |
|
86 |
|
|
|
87 |
|
|
|
85 | assert len(w) == 1 | |
|
86 | assert "Moving" in str(w[0]) | |
|
88 | 87 | finally: |
|
89 | 88 | tmphome.cleanup() |
|
90 | 89 | |
@@ -106,10 +105,11 b' def test_get_ipython_dir_4():' | |||
|
106 | 105 | }), warnings.catch_warnings(record=True) as w: |
|
107 | 106 | ipdir = paths.get_ipython_dir() |
|
108 | 107 | |
|
109 |
|
|
|
108 | assert ipdir == os.path.join(HOME_TEST_DIR, ".ipython") | |
|
110 | 109 | if sys.platform != 'darwin': |
|
111 |
|
|
|
112 |
|
|
|
110 | assert len(w) == 1 | |
|
111 | assert "Ignoring" in str(w[0]) | |
|
112 | ||
|
113 | 113 | |
|
114 | 114 | def test_get_ipython_dir_5(): |
|
115 | 115 | """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist.""" |
@@ -128,7 +128,7 b' def test_get_ipython_dir_5():' | |||
|
128 | 128 | }): |
|
129 | 129 | ipdir = paths.get_ipython_dir() |
|
130 | 130 | |
|
131 |
|
|
|
131 | assert ipdir == IP_TEST_DIR | |
|
132 | 132 | |
|
133 | 133 | def test_get_ipython_dir_6(): |
|
134 | 134 | """test_get_ipython_dir_6, use home over XDG if defined and neither exist.""" |
@@ -146,8 +146,8 b' def test_get_ipython_dir_6():' | |||
|
146 | 146 | }), warnings.catch_warnings(record=True) as w: |
|
147 | 147 | ipdir = paths.get_ipython_dir() |
|
148 | 148 | |
|
149 |
|
|
|
150 |
|
|
|
149 | assert ipdir == os.path.join(HOME_TEST_DIR, ".ipython") | |
|
150 | assert len(w) == 0 | |
|
151 | 151 | |
|
152 | 152 | def test_get_ipython_dir_7(): |
|
153 | 153 | """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR""" |
@@ -155,7 +155,8 b' def test_get_ipython_dir_7():' | |||
|
155 | 155 | with modified_env({'IPYTHONDIR': os.path.join('~', 'somewhere')}), \ |
|
156 | 156 | patch.object(paths, '_writable_dir', return_value=True): |
|
157 | 157 | ipdir = paths.get_ipython_dir() |
|
158 |
|
|
|
158 | assert ipdir == os.path.join(home_dir, "somewhere") | |
|
159 | ||
|
159 | 160 | |
|
160 | 161 | @skip_win32 |
|
161 | 162 | def test_get_ipython_dir_8(): |
@@ -164,14 +165,16 b' def test_get_ipython_dir_8():' | |||
|
164 | 165 | # test only when HOME directory actually writable |
|
165 | 166 | return |
|
166 | 167 | |
|
167 |
with patch.object(paths, |
|
|
168 |
|
|
|
169 |
|
|
|
170 | 'IPYTHON_DIR': None, | |
|
171 |
|
|
|
172 | 'HOME': '/', | |
|
173 |
|
|
|
174 | nt.assert_equal(paths.get_ipython_dir(), '/.ipython') | |
|
168 | with patch.object(paths, "_writable_dir", lambda path: bool(path)), patch.object( | |
|
169 | paths, "get_xdg_dir", return_value=None | |
|
170 | ), modified_env( | |
|
171 | { | |
|
172 | "IPYTHON_DIR": None, | |
|
173 | "IPYTHONDIR": None, | |
|
174 | "HOME": "/", | |
|
175 | } | |
|
176 | ): | |
|
177 | assert paths.get_ipython_dir() == "/.ipython" | |
|
175 | 178 | |
|
176 | 179 | |
|
177 | 180 | def test_get_ipython_cache_dir(): |
@@ -181,18 +184,16 b' def test_get_ipython_cache_dir():' | |||
|
181 | 184 | os.makedirs(os.path.join(HOME_TEST_DIR, ".cache")) |
|
182 | 185 | with modified_env({'XDG_CACHE_HOME': None}): |
|
183 | 186 | ipdir = paths.get_ipython_cache_dir() |
|
184 |
|
|
|
185 | ipdir) | |
|
187 | assert os.path.join(HOME_TEST_DIR, ".cache", "ipython") == ipdir | |
|
186 | 188 | assert_isdir(ipdir) |
|
187 | 189 | |
|
188 | 190 | # test env override |
|
189 | 191 | with modified_env({"XDG_CACHE_HOME": XDG_CACHE_DIR}): |
|
190 | 192 | ipdir = paths.get_ipython_cache_dir() |
|
191 | 193 | assert_isdir(ipdir) |
|
192 |
|
|
|
194 | assert ipdir == os.path.join(XDG_CACHE_DIR, "ipython") | |
|
193 | 195 | else: |
|
194 |
|
|
|
195 | paths.get_ipython_dir()) | |
|
196 | assert paths.get_ipython_cache_dir() == paths.get_ipython_dir() | |
|
196 | 197 | |
|
197 | 198 | def test_get_ipython_package_dir(): |
|
198 | 199 | ipdir = paths.get_ipython_package_dir() |
@@ -27,8 +27,6 b' import tempfile' | |||
|
27 | 27 | from pathlib import Path |
|
28 | 28 | from unittest import TestCase |
|
29 | 29 | |
|
30 | import nose.tools as nt | |
|
31 | ||
|
32 | 30 | from IPython.core.profileapp import list_profiles_in, list_bundled_profiles |
|
33 | 31 | from IPython.core.profiledir import ProfileDir |
|
34 | 32 | |
@@ -79,7 +77,7 b' def win32_without_pywin32():' | |||
|
79 | 77 | except ImportError: |
|
80 | 78 | return True |
|
81 | 79 | return False |
|
82 | ||
|
80 | ||
|
83 | 81 | |
|
84 | 82 | class ProfileStartupTest(TestCase): |
|
85 | 83 | def setUp(self): |
@@ -114,7 +112,7 b' class ProfileStartupTest(TestCase):' | |||
|
114 | 112 | self.init('00-start.ipy', '%xmode plain\n', '') |
|
115 | 113 | self.validate('Exception reporting mode: Plain') |
|
116 | 114 | |
|
117 | ||
|
115 | ||
|
118 | 116 | def test_list_profiles_in(): |
|
119 | 117 | # No need to remove these directories and files, as they will get nuked in |
|
120 | 118 | # the module-level teardown. |
@@ -127,7 +125,7 b' def test_list_profiles_in():' | |||
|
127 | 125 | with open(td / "profile_file", "w") as f: |
|
128 | 126 | f.write("I am not a profile directory") |
|
129 | 127 | profiles = list_profiles_in(td) |
|
130 | ||
|
128 | ||
|
131 | 129 | # unicode normalization can turn u'ünicode' into u'u\0308nicode', |
|
132 | 130 | # so only check for *nicode, and that creating a ProfileDir from the |
|
133 | 131 | # name remains valid |
@@ -139,14 +137,14 b' def test_list_profiles_in():' | |||
|
139 | 137 | found_unicode = True |
|
140 | 138 | break |
|
141 | 139 | if dec.unicode_paths: |
|
142 |
|
|
|
143 |
|
|
|
140 | assert found_unicode is True | |
|
141 | assert set(profiles) == {"foo", "hello"} | |
|
144 | 142 | |
|
145 | 143 | |
|
146 | 144 | def test_list_bundled_profiles(): |
|
147 | 145 | # This variable will need to be updated when a new profile gets bundled |
|
148 | 146 | bundled = sorted(list_bundled_profiles()) |
|
149 |
|
|
|
147 | assert bundled == [] | |
|
150 | 148 | |
|
151 | 149 | |
|
152 | 150 | def test_profile_create_ipython_dir(): |
@@ -167,4 +165,3 b' def test_profile_create_ipython_dir():' | |||
|
167 | 165 | assert Path(profile_dir).exists() |
|
168 | 166 | ipython_config = profile_dir / "ipython_config.py" |
|
169 | 167 | assert Path(ipython_config).exists() |
|
170 |
@@ -12,12 +12,10 b' import matplotlib' | |||
|
12 | 12 | matplotlib.use('Agg') |
|
13 | 13 | from matplotlib.figure import Figure |
|
14 | 14 | |
|
15 | from nose import SkipTest | |
|
16 | import nose.tools as nt | |
|
17 | ||
|
18 | 15 | from matplotlib import pyplot as plt |
|
19 | import matplotlib_inline | |
|
16 | from matplotlib_inline import backend_inline | |
|
20 | 17 | import numpy as np |
|
18 | import pytest | |
|
21 | 19 | |
|
22 | 20 | from IPython.core.getipython import get_ipython |
|
23 | 21 | from IPython.core.interactiveshell import InteractiveShell |
@@ -30,7 +28,7 b' from IPython.testing import decorators as dec' | |||
|
30 | 28 | def test_figure_to_svg(): |
|
31 | 29 | # simple empty-figure test |
|
32 | 30 | fig = plt.figure() |
|
33 |
|
|
|
31 | assert pt.print_figure(fig, "svg") is None | |
|
34 | 32 | |
|
35 | 33 | plt.close('all') |
|
36 | 34 | |
@@ -39,8 +37,9 b' def test_figure_to_svg():' | |||
|
39 | 37 | ax = fig.add_subplot(1,1,1) |
|
40 | 38 | ax.plot([1,2,3]) |
|
41 | 39 | plt.draw() |
|
42 |
svg = pt.print_figure(fig, |
|
|
43 |
|
|
|
40 | svg = pt.print_figure(fig, "svg")[:100].lower() | |
|
41 | assert "doctype svg" in svg | |
|
42 | ||
|
44 | 43 | |
|
45 | 44 | def _check_pil_jpeg_bytes(): |
|
46 | 45 | """Skip if PIL can't write JPEGs to BytesIO objects""" |
@@ -53,7 +52,7 b' def _check_pil_jpeg_bytes():' | |||
|
53 | 52 | img.save(buf, 'jpeg') |
|
54 | 53 | except Exception as e: |
|
55 | 54 | ename = e.__class__.__name__ |
|
56 |
raise |
|
|
55 | raise pytest.skip("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e)) from e | |
|
57 | 56 | |
|
58 | 57 | @dec.skip_without("PIL.Image") |
|
59 | 58 | def test_figure_to_jpeg(): |
@@ -69,7 +68,7 b' def test_figure_to_jpeg():' | |||
|
69 | 68 | def test_retina_figure(): |
|
70 | 69 | # simple empty-figure test |
|
71 | 70 | fig = plt.figure() |
|
72 |
|
|
|
71 | assert pt.retina_figure(fig) == None | |
|
73 | 72 | plt.close('all') |
|
74 | 73 | |
|
75 | 74 | fig = plt.figure() |
@@ -78,8 +77,9 b' def test_retina_figure():' | |||
|
78 | 77 | plt.draw() |
|
79 | 78 | png, md = pt.retina_figure(fig) |
|
80 | 79 | assert png.startswith(_PNG) |
|
81 |
|
|
|
82 |
|
|
|
80 | assert "width" in md | |
|
81 | assert "height" in md | |
|
82 | ||
|
83 | 83 | |
|
84 | 84 | _fmt_mime_map = { |
|
85 | 85 | 'png': 'image/png', |
@@ -95,9 +95,9 b' def test_select_figure_formats_str():' | |||
|
95 | 95 | pt.select_figure_formats(ip, fmt) |
|
96 | 96 | for mime, f in ip.display_formatter.formatters.items(): |
|
97 | 97 | if mime == active_mime: |
|
98 |
|
|
|
98 | assert Figure in f | |
|
99 | 99 | else: |
|
100 |
|
|
|
100 | assert Figure not in f | |
|
101 | 101 | |
|
102 | 102 | def test_select_figure_formats_kwargs(): |
|
103 | 103 | ip = get_ipython() |
@@ -134,24 +134,25 b' def test_select_figure_formats_set():' | |||
|
134 | 134 | pt.select_figure_formats(ip, fmts) |
|
135 | 135 | for mime, f in ip.display_formatter.formatters.items(): |
|
136 | 136 | if mime in active_mimes: |
|
137 |
|
|
|
137 | assert Figure in f | |
|
138 | 138 | else: |
|
139 |
|
|
|
139 | assert Figure not in f | |
|
140 | 140 | |
|
141 | 141 | def test_select_figure_formats_bad(): |
|
142 | 142 | ip = get_ipython() |
|
143 |
with |
|
|
143 | with pytest.raises(ValueError): | |
|
144 | 144 | pt.select_figure_formats(ip, 'foo') |
|
145 |
with |
|
|
145 | with pytest.raises(ValueError): | |
|
146 | 146 | pt.select_figure_formats(ip, {'png', 'foo'}) |
|
147 |
with |
|
|
147 | with pytest.raises(ValueError): | |
|
148 | 148 | pt.select_figure_formats(ip, ['retina', 'pdf', 'bar', 'bad']) |
|
149 | 149 | |
|
150 | 150 | def test_import_pylab(): |
|
151 | 151 | ns = {} |
|
152 | 152 | pt.import_pylab(ns, import_all=False) |
|
153 |
|
|
|
154 |
|
|
|
153 | assert "plt" in ns | |
|
154 | assert ns["np"] == np | |
|
155 | ||
|
155 | 156 | |
|
156 | 157 | from traitlets.config import Config |
|
157 | 158 | |
@@ -182,15 +183,13 b' class TestPylabSwitch(object):' | |||
|
182 | 183 | pt.activate_matplotlib = act_mpl |
|
183 | 184 | self._save_ip = pt.import_pylab |
|
184 | 185 | pt.import_pylab = lambda *a,**kw:None |
|
185 |
self._save_cis = |
|
|
186 |
|
|
|
187 | lambda *a, **kw: None | |
|
188 | ) | |
|
186 | self._save_cis = backend_inline.configure_inline_support | |
|
187 | backend_inline.configure_inline_support = lambda *a, **kw: None | |
|
189 | 188 | |
|
190 | 189 | def teardown(self): |
|
191 | 190 | pt.activate_matplotlib = self._save_am |
|
192 | 191 | pt.import_pylab = self._save_ip |
|
193 |
|
|
|
192 | backend_inline.configure_inline_support = self._save_cis | |
|
194 | 193 | import matplotlib |
|
195 | 194 | matplotlib.rcParams = self._saved_rcParams |
|
196 | 195 | matplotlib.rcParamsOrig = self._saved_rcParamsOrig |
@@ -199,68 +198,68 b' class TestPylabSwitch(object):' | |||
|
199 | 198 | |
|
200 | 199 | s = self.Shell() |
|
201 | 200 | gui, backend = s.enable_matplotlib(None) |
|
202 |
|
|
|
203 |
|
|
|
201 | assert gui == "qt" | |
|
202 | assert s.pylab_gui_select == "qt" | |
|
204 | 203 | |
|
205 |
gui, backend = s.enable_matplotlib( |
|
|
206 |
|
|
|
207 |
|
|
|
204 | gui, backend = s.enable_matplotlib("inline") | |
|
205 | assert gui == "inline" | |
|
206 | assert s.pylab_gui_select == "qt" | |
|
208 | 207 | |
|
209 |
gui, backend = s.enable_matplotlib( |
|
|
210 |
|
|
|
211 |
|
|
|
208 | gui, backend = s.enable_matplotlib("qt") | |
|
209 | assert gui == "qt" | |
|
210 | assert s.pylab_gui_select == "qt" | |
|
212 | 211 | |
|
213 |
gui, backend = s.enable_matplotlib( |
|
|
214 |
|
|
|
215 |
|
|
|
212 | gui, backend = s.enable_matplotlib("inline") | |
|
213 | assert gui == "inline" | |
|
214 | assert s.pylab_gui_select == "qt" | |
|
216 | 215 | |
|
217 | 216 | gui, backend = s.enable_matplotlib() |
|
218 |
|
|
|
219 |
|
|
|
217 | assert gui == "qt" | |
|
218 | assert s.pylab_gui_select == "qt" | |
|
220 | 219 | |
|
221 | 220 | def test_inline(self): |
|
222 | 221 | s = self.Shell() |
|
223 |
gui, backend = s.enable_matplotlib( |
|
|
224 |
|
|
|
225 |
|
|
|
222 | gui, backend = s.enable_matplotlib("inline") | |
|
223 | assert gui == "inline" | |
|
224 | assert s.pylab_gui_select == None | |
|
226 | 225 | |
|
227 |
gui, backend = s.enable_matplotlib( |
|
|
228 |
|
|
|
229 |
|
|
|
226 | gui, backend = s.enable_matplotlib("inline") | |
|
227 | assert gui == "inline" | |
|
228 | assert s.pylab_gui_select == None | |
|
230 | 229 | |
|
231 |
gui, backend = s.enable_matplotlib( |
|
|
232 |
|
|
|
233 |
|
|
|
230 | gui, backend = s.enable_matplotlib("qt") | |
|
231 | assert gui == "qt" | |
|
232 | assert s.pylab_gui_select == "qt" | |
|
234 | 233 | |
|
235 | 234 | def test_inline_twice(self): |
|
236 | 235 | "Using '%matplotlib inline' twice should not reset formatters" |
|
237 | 236 | |
|
238 | 237 | ip = self.Shell() |
|
239 |
gui, backend = ip.enable_matplotlib( |
|
|
240 |
|
|
|
238 | gui, backend = ip.enable_matplotlib("inline") | |
|
239 | assert gui == "inline" | |
|
241 | 240 | |
|
242 | 241 | fmts = {'png'} |
|
243 | 242 | active_mimes = {_fmt_mime_map[fmt] for fmt in fmts} |
|
244 | 243 | pt.select_figure_formats(ip, fmts) |
|
245 | 244 | |
|
246 |
gui, backend = ip.enable_matplotlib( |
|
|
247 |
|
|
|
245 | gui, backend = ip.enable_matplotlib("inline") | |
|
246 | assert gui == "inline" | |
|
248 | 247 | |
|
249 | 248 | for mime, f in ip.display_formatter.formatters.items(): |
|
250 | 249 | if mime in active_mimes: |
|
251 |
|
|
|
250 | assert Figure in f | |
|
252 | 251 | else: |
|
253 |
|
|
|
252 | assert Figure not in f | |
|
254 | 253 | |
|
255 | 254 | def test_qt_gtk(self): |
|
256 | 255 | s = self.Shell() |
|
257 |
gui, backend = s.enable_matplotlib( |
|
|
258 |
|
|
|
259 |
|
|
|
256 | gui, backend = s.enable_matplotlib("qt") | |
|
257 | assert gui == "qt" | |
|
258 | assert s.pylab_gui_select == "qt" | |
|
260 | 259 | |
|
261 |
gui, backend = s.enable_matplotlib( |
|
|
262 |
|
|
|
263 |
|
|
|
260 | gui, backend = s.enable_matplotlib("gtk") | |
|
261 | assert gui == "qt" | |
|
262 | assert s.pylab_gui_select == "qt" | |
|
264 | 263 | |
|
265 | 264 | |
|
266 | 265 | def test_no_gui_backends(): |
@@ -26,8 +26,7 b' import textwrap' | |||
|
26 | 26 | import unittest |
|
27 | 27 | from unittest.mock import patch |
|
28 | 28 | |
|
29 | import nose.tools as nt | |
|
30 | from nose import SkipTest | |
|
29 | import pytest | |
|
31 | 30 | |
|
32 | 31 | from IPython.testing import decorators as dec |
|
33 | 32 | from IPython.testing import tools as tt |
@@ -168,13 +167,13 b' class TestMagicRunPass(tt.TempFileMixin):' | |||
|
168 | 167 | def setUp(self): |
|
169 | 168 | content = "a = [1,2,3]\nb = 1" |
|
170 | 169 | self.mktmp(content) |
|
171 | ||
|
170 | ||
|
172 | 171 | def run_tmpfile(self): |
|
173 | 172 | _ip = get_ipython() |
|
174 | 173 | # This fails on Windows if self.tmpfile.name has spaces or "~" in it. |
|
175 | 174 | # See below and ticket https://bugs.launchpad.net/bugs/366353 |
|
176 | 175 | _ip.magic('run %s' % self.fname) |
|
177 | ||
|
176 | ||
|
178 | 177 | def run_tmpfile_p(self): |
|
179 | 178 | _ip = get_ipython() |
|
180 | 179 | # This fails on Windows if self.tmpfile.name has spaces or "~" in it. |
@@ -188,7 +187,7 b' class TestMagicRunPass(tt.TempFileMixin):' | |||
|
188 | 187 | bid1 = id(_ip.user_ns['__builtins__']) |
|
189 | 188 | self.run_tmpfile() |
|
190 | 189 | bid2 = id(_ip.user_ns['__builtins__']) |
|
191 |
|
|
|
190 | assert bid1 == bid2 | |
|
192 | 191 | |
|
193 | 192 | def test_builtins_type(self): |
|
194 | 193 | """Check that the type of __builtins__ doesn't change with %run. |
@@ -199,9 +198,9 b' class TestMagicRunPass(tt.TempFileMixin):' | |||
|
199 | 198 | """ |
|
200 | 199 | _ip = get_ipython() |
|
201 | 200 | self.run_tmpfile() |
|
202 |
|
|
|
203 | ||
|
204 |
def test_run_profile( |
|
|
201 | assert type(_ip.user_ns["__builtins__"]) == type(sys) | |
|
202 | ||
|
203 | def test_run_profile(self): | |
|
205 | 204 | """Test that the option -p, which invokes the profiler, do not |
|
206 | 205 | crash by invoking execfile""" |
|
207 | 206 | self.run_tmpfile_p() |
@@ -232,9 +231,9 b' class TestMagicRunSimple(tt.TempFileMixin):' | |||
|
232 | 231 | src = ("class foo: pass\n" |
|
233 | 232 | "def f(): return foo()") |
|
234 | 233 | self.mktmp(src) |
|
235 |
_ip.magic( |
|
|
236 |
_ip.run_cell( |
|
|
237 |
|
|
|
234 | _ip.magic("run %s" % self.fname) | |
|
235 | _ip.run_cell("t = isinstance(f(), foo)") | |
|
236 | assert _ip.user_ns["t"] is True | |
|
238 | 237 | |
|
239 | 238 | def test_obj_del(self): |
|
240 | 239 | """Test that object's __del__ methods are called on exit.""" |
@@ -242,7 +241,7 b' class TestMagicRunSimple(tt.TempFileMixin):' | |||
|
242 | 241 | try: |
|
243 | 242 | import win32api |
|
244 | 243 | except ImportError as e: |
|
245 | raise SkipTest("Test requires pywin32") from e | |
|
244 | raise unittest.SkipTest("Test requires pywin32") from e | |
|
246 | 245 | src = ("class A(object):\n" |
|
247 | 246 | " def __del__(self):\n" |
|
248 | 247 | " print('object A deleted')\n" |
@@ -250,42 +249,41 b' class TestMagicRunSimple(tt.TempFileMixin):' | |||
|
250 | 249 | self.mktmp(src) |
|
251 | 250 | err = None |
|
252 | 251 | tt.ipexec_validate(self.fname, 'object A deleted', err) |
|
253 | ||
|
252 | ||
|
254 | 253 | def test_aggressive_namespace_cleanup(self): |
|
255 | 254 | """Test that namespace cleanup is not too aggressive GH-238 |
|
256 | 255 | |
|
257 | 256 | Returning from another run magic deletes the namespace""" |
|
258 | 257 | # see ticket https://github.com/ipython/ipython/issues/238 |
|
259 | ||
|
258 | ||
|
260 | 259 | with tt.TempFileMixin() as empty: |
|
261 |
empty.mktmp( |
|
|
260 | empty.mktmp("") | |
|
262 | 261 | # On Windows, the filename will have \users in it, so we need to use the |
|
263 | 262 | # repr so that the \u becomes \\u. |
|
264 |
src = ( |
|
|
265 |
|
|
|
266 |
|
|
|
267 |
|
|
|
268 | " except NameError as e:\n" | |
|
269 |
|
|
|
270 | " break\n" % ('run ' + empty.fname)) | |
|
263 | src = ( | |
|
264 | "ip = get_ipython()\n" | |
|
265 | "for i in range(5):\n" | |
|
266 | " try:\n" | |
|
267 | " ip.magic(%r)\n" | |
|
268 | " except NameError as e:\n" | |
|
269 | " print(i)\n" | |
|
270 | " break\n" % ("run " + empty.fname) | |
|
271 | ) | |
|
271 | 272 | self.mktmp(src) |
|
272 |
_ip.magic( |
|
|
273 |
_ip.run_cell( |
|
|
274 |
|
|
|
275 | ||
|
273 | _ip.magic("run %s" % self.fname) | |
|
274 | _ip.run_cell("ip == get_ipython()") | |
|
275 | assert _ip.user_ns["i"] == 4 | |
|
276 | ||
|
276 | 277 | def test_run_second(self): |
|
277 | """Test that running a second file doesn't clobber the first, gh-3547 | |
|
278 | """ | |
|
279 | self.mktmp("avar = 1\n" | |
|
280 | "def afunc():\n" | |
|
281 | " return avar\n") | |
|
278 | """Test that running a second file doesn't clobber the first, gh-3547""" | |
|
279 | self.mktmp("avar = 1\n" "def afunc():\n" " return avar\n") | |
|
282 | 280 | |
|
283 | 281 | with tt.TempFileMixin() as empty: |
|
284 | 282 | empty.mktmp("") |
|
285 | ||
|
286 |
_ip.magic( |
|
|
287 |
_ip.magic( |
|
|
288 |
|
|
|
283 | ||
|
284 | _ip.magic("run %s" % self.fname) | |
|
285 | _ip.magic("run %s" % empty.fname) | |
|
286 | assert _ip.user_ns["afunc"]() == 1 | |
|
289 | 287 | |
|
290 | 288 | @dec.skip_win32 |
|
291 | 289 | def test_tclass(self): |
@@ -312,24 +310,24 b' tclass.py: deleting object: C-third' | |||
|
312 | 310 | self.mktmp(src) |
|
313 | 311 | _ip.run_cell("zz = 23") |
|
314 | 312 | try: |
|
315 |
_ip.magic( |
|
|
316 |
|
|
|
313 | _ip.magic("run -i %s" % self.fname) | |
|
314 | assert _ip.user_ns["yy"] == 23 | |
|
317 | 315 | finally: |
|
318 | 316 | _ip.magic('reset -f') |
|
319 | ||
|
317 | ||
|
320 | 318 | _ip.run_cell("zz = 23") |
|
321 | 319 | try: |
|
322 |
_ip.magic( |
|
|
323 |
|
|
|
320 | _ip.magic("run -i %s" % self.fname) | |
|
321 | assert _ip.user_ns["yy"] == 23 | |
|
324 | 322 | finally: |
|
325 | 323 | _ip.magic('reset -f') |
|
326 | ||
|
324 | ||
|
327 | 325 | def test_unicode(self): |
|
328 | 326 | """Check that files in odd encodings are accepted.""" |
|
329 | 327 | mydir = os.path.dirname(__file__) |
|
330 | 328 | na = os.path.join(mydir, 'nonascii.py') |
|
331 | 329 | _ip.magic('run "%s"' % na) |
|
332 |
|
|
|
330 | assert _ip.user_ns["u"] == "Ўт№Ф" | |
|
333 | 331 | |
|
334 | 332 | def test_run_py_file_attribute(self): |
|
335 | 333 | """Test handling of `__file__` attribute in `%run <file>.py`.""" |
@@ -342,10 +340,10 b' tclass.py: deleting object: C-third' | |||
|
342 | 340 | |
|
343 | 341 | # Check that __file__ was equal to the filename in the script's |
|
344 | 342 | # namespace. |
|
345 |
|
|
|
343 | assert _ip.user_ns["t"] == self.fname | |
|
346 | 344 | |
|
347 | 345 | # Check that __file__ was not leaked back into user_ns. |
|
348 |
|
|
|
346 | assert file1 == file2 | |
|
349 | 347 | |
|
350 | 348 | def test_run_ipy_file_attribute(self): |
|
351 | 349 | """Test handling of `__file__` attribute in `%run <file.ipy>`.""" |
@@ -358,10 +356,10 b' tclass.py: deleting object: C-third' | |||
|
358 | 356 | |
|
359 | 357 | # Check that __file__ was equal to the filename in the script's |
|
360 | 358 | # namespace. |
|
361 |
|
|
|
359 | assert _ip.user_ns["t"] == self.fname | |
|
362 | 360 | |
|
363 | 361 | # Check that __file__ was not leaked back into user_ns. |
|
364 |
|
|
|
362 | assert file1 == file2 | |
|
365 | 363 | |
|
366 | 364 | def test_run_formatting(self): |
|
367 | 365 | """ Test that %run -t -N<N> does not raise a TypeError for N > 1.""" |
@@ -369,14 +367,14 b' tclass.py: deleting object: C-third' | |||
|
369 | 367 | self.mktmp(src) |
|
370 | 368 | _ip.magic('run -t -N 1 %s' % self.fname) |
|
371 | 369 | _ip.magic('run -t -N 10 %s' % self.fname) |
|
372 | ||
|
370 | ||
|
373 | 371 | def test_ignore_sys_exit(self): |
|
374 | 372 | """Test the -e option to ignore sys.exit()""" |
|
375 | 373 | src = "import sys; sys.exit(1)" |
|
376 | 374 | self.mktmp(src) |
|
377 | 375 | with tt.AssertPrints('SystemExit'): |
|
378 | 376 | _ip.magic('run %s' % self.fname) |
|
379 | ||
|
377 | ||
|
380 | 378 | with tt.AssertNotPrints('SystemExit'): |
|
381 | 379 | _ip.magic('run -e %s' % self.fname) |
|
382 | 380 | |
@@ -391,19 +389,19 b' tclass.py: deleting object: C-third' | |||
|
391 | 389 | ) |
|
392 | 390 | src = writes(nb, version=4) |
|
393 | 391 | self.mktmp(src, ext='.ipynb') |
|
394 | ||
|
392 | ||
|
395 | 393 | _ip.magic("run %s" % self.fname) |
|
396 | ||
|
397 |
|
|
|
394 | ||
|
395 | assert _ip.user_ns["answer"] == 42 | |
|
398 | 396 | |
|
399 | 397 | def test_run_nb_error(self): |
|
400 | 398 | """Test %run notebook.ipynb error""" |
|
401 | 399 | from nbformat import v4, writes |
|
402 | 400 | # %run when a file name isn't provided |
|
403 |
|
|
|
401 | pytest.raises(Exception, _ip.magic, "run") | |
|
404 | 402 | |
|
405 | 403 | # %run when a file doesn't exist |
|
406 |
|
|
|
404 | pytest.raises(Exception, _ip.magic, "run foobar.ipynb") | |
|
407 | 405 | |
|
408 | 406 | # %run on a notebook with an error |
|
409 | 407 | nb = v4.new_notebook( |
@@ -413,15 +411,15 b' tclass.py: deleting object: C-third' | |||
|
413 | 411 | ) |
|
414 | 412 | src = writes(nb, version=4) |
|
415 | 413 | self.mktmp(src, ext='.ipynb') |
|
416 |
|
|
|
414 | pytest.raises(Exception, _ip.magic, "run %s" % self.fname) | |
|
417 | 415 | |
|
418 | 416 | def test_file_options(self): |
|
419 | 417 | src = ('import sys\n' |
|
420 | 418 | 'a = " ".join(sys.argv[1:])\n') |
|
421 | 419 | self.mktmp(src) |
|
422 |
test_opts = |
|
|
423 |
_ip.run_line_magic("run", |
|
|
424 |
|
|
|
420 | test_opts = "-x 3 --verbose" | |
|
421 | _ip.run_line_magic("run", "{0} {1}".format(self.fname, test_opts)) | |
|
422 | assert _ip.user_ns["a"] == test_opts | |
|
425 | 423 | |
|
426 | 424 | |
|
427 | 425 | class TestMagicRunWithPackage(unittest.TestCase): |
@@ -500,33 +498,34 b' class TestMagicRunWithPackage(unittest.TestCase):' | |||
|
500 | 498 | self.check_run_submodule('relative', '-d') |
|
501 | 499 | |
|
502 | 500 | def test_module_options(self): |
|
503 |
_ip.user_ns.pop( |
|
|
504 |
test_opts = |
|
|
505 |
_ip.run_line_magic( |
|
|
506 |
|
|
|
501 | _ip.user_ns.pop("a", None) | |
|
502 | test_opts = "-x abc -m test" | |
|
503 | _ip.run_line_magic("run", "-m {0}.args {1}".format(self.package, test_opts)) | |
|
504 | assert _ip.user_ns["a"] == test_opts | |
|
507 | 505 | |
|
508 | 506 | def test_module_options_with_separator(self): |
|
509 |
_ip.user_ns.pop( |
|
|
510 |
test_opts = |
|
|
511 |
_ip.run_line_magic( |
|
|
512 |
|
|
|
507 | _ip.user_ns.pop("a", None) | |
|
508 | test_opts = "-x abc -m test" | |
|
509 | _ip.run_line_magic("run", "-m {0}.args -- {1}".format(self.package, test_opts)) | |
|
510 | assert _ip.user_ns["a"] == test_opts | |
|
511 | ||
|
513 | 512 | |
|
514 | 513 | def test_run__name__(): |
|
515 | 514 | with TemporaryDirectory() as td: |
|
516 | 515 | path = pjoin(td, 'foo.py') |
|
517 | 516 | with open(path, 'w') as f: |
|
518 | 517 | f.write("q = __name__") |
|
519 | ||
|
520 |
_ip.user_ns.pop( |
|
|
521 |
_ip.magic( |
|
|
522 |
|
|
|
523 | ||
|
524 |
_ip.magic( |
|
|
525 |
|
|
|
518 | ||
|
519 | _ip.user_ns.pop("q", None) | |
|
520 | _ip.magic("run {}".format(path)) | |
|
521 | assert _ip.user_ns.pop("q") == "__main__" | |
|
522 | ||
|
523 | _ip.magic("run -n {}".format(path)) | |
|
524 | assert _ip.user_ns.pop("q") == "foo" | |
|
526 | 525 | |
|
527 | 526 | try: |
|
528 |
_ip.magic( |
|
|
529 |
|
|
|
527 | _ip.magic("run -i -n {}".format(path)) | |
|
528 | assert _ip.user_ns.pop("q") == "foo" | |
|
530 | 529 | finally: |
|
531 | 530 | _ip.magic('reset -f') |
|
532 | 531 | |
@@ -546,9 +545,9 b' def test_run_tb():' | |||
|
546 | 545 | with capture_output() as io: |
|
547 | 546 | _ip.magic('run {}'.format(path)) |
|
548 | 547 | out = io.stdout |
|
549 |
|
|
|
550 |
|
|
|
551 |
|
|
|
548 | assert "execfile" not in out | |
|
549 | assert "RuntimeError" in out | |
|
550 | assert out.count("---->") == 3 | |
|
552 | 551 | del ip.user_ns['bar'] |
|
553 | 552 | del ip.user_ns['foo'] |
|
554 | 553 | |
@@ -572,10 +571,10 b' def test_multiprocessing_run():' | |||
|
572 | 571 | _ip.run_line_magic('run', path) |
|
573 | 572 | _ip.run_cell("i_m_undefined") |
|
574 | 573 | out = io.stdout |
|
575 |
|
|
|
576 |
|
|
|
577 |
|
|
|
578 |
|
|
|
574 | assert "hoy" in out | |
|
575 | assert "AttributeError" not in out | |
|
576 | assert "NameError" in out | |
|
577 | assert out.count("---->") == 1 | |
|
579 | 578 | except: |
|
580 | 579 | raise |
|
581 | 580 | finally: |
@@ -595,7 +594,6 b' def test_script_tb():' | |||
|
595 | 594 | "foo()", |
|
596 | 595 | ])) |
|
597 | 596 | out, err = tt.ipexec(path) |
|
598 |
|
|
|
599 |
|
|
|
600 |
|
|
|
601 | ||
|
597 | assert "execfile" not in out | |
|
598 | assert "RuntimeError" in out | |
|
599 | assert out.count("---->") == 3 |
@@ -1,38 +1,38 b'' | |||
|
1 | 1 | # coding: utf-8 |
|
2 | import nose.tools as nt | |
|
3 | 2 | |
|
4 | 3 | from IPython.core.splitinput import split_user_input, LineInfo |
|
5 | 4 | from IPython.testing import tools as tt |
|
6 | 5 | |
|
7 | 6 | tests = [ |
|
8 |
( |
|
|
9 |
( |
|
|
10 |
( |
|
|
11 |
( |
|
|
12 |
( |
|
|
13 |
( |
|
|
14 |
( |
|
|
15 |
( |
|
|
16 |
( |
|
|
17 |
( |
|
|
18 |
( |
|
|
19 |
( |
|
|
20 |
( |
|
|
21 |
( |
|
|
22 |
( |
|
|
23 |
( |
|
|
24 |
( |
|
|
25 |
( |
|
|
26 |
( |
|
|
27 |
( |
|
|
28 |
( |
|
|
29 | ] | |
|
30 |
tests.append(( |
|
|
7 | ("x=1", ("", "", "x", "=1")), | |
|
8 | ("?", ("", "?", "", "")), | |
|
9 | ("??", ("", "??", "", "")), | |
|
10 | (" ?", (" ", "?", "", "")), | |
|
11 | (" ??", (" ", "??", "", "")), | |
|
12 | ("??x", ("", "??", "x", "")), | |
|
13 | ("?x=1", ("", "?", "x", "=1")), | |
|
14 | ("!ls", ("", "!", "ls", "")), | |
|
15 | (" !ls", (" ", "!", "ls", "")), | |
|
16 | ("!!ls", ("", "!!", "ls", "")), | |
|
17 | (" !!ls", (" ", "!!", "ls", "")), | |
|
18 | (",ls", ("", ",", "ls", "")), | |
|
19 | (";ls", ("", ";", "ls", "")), | |
|
20 | (" ;ls", (" ", ";", "ls", "")), | |
|
21 | ("f.g(x)", ("", "", "f.g", "(x)")), | |
|
22 | ("f.g (x)", ("", "", "f.g", "(x)")), | |
|
23 | ("?%hist1", ("", "?", "%hist1", "")), | |
|
24 | ("?%%hist2", ("", "?", "%%hist2", "")), | |
|
25 | ("??%hist3", ("", "??", "%hist3", "")), | |
|
26 | ("??%%hist4", ("", "??", "%%hist4", "")), | |
|
27 | ("?x*", ("", "?", "x*", "")), | |
|
28 | ] | |
|
29 | tests.append(("Pérez Fernando", ("", "", "Pérez", "Fernando"))) | |
|
30 | ||
|
31 | 31 | |
|
32 | 32 | def test_split_user_input(): |
|
33 | 33 | return tt.check_pairs(split_user_input, tests) |
|
34 | 34 | |
|
35 | 35 | def test_LineInfo(): |
|
36 | 36 | """Simple test for LineInfo construction and str()""" |
|
37 |
linfo = LineInfo( |
|
|
38 |
|
|
|
37 | linfo = LineInfo(" %cd /home") | |
|
38 | assert str(linfo) == "LineInfo [ |%|cd|/home]" |
@@ -21,7 +21,6 b' import random' | |||
|
21 | 21 | import time |
|
22 | 22 | from io import StringIO |
|
23 | 23 | |
|
24 | import nose.tools as nt | |
|
25 | 24 | import IPython.testing.tools as tt |
|
26 | 25 | |
|
27 | 26 | from unittest import TestCase |
@@ -227,12 +226,12 b' class TestAutoreload(Fixture):' | |||
|
227 | 226 | self.shell.run_code("from %s import MyClass" % mod_name) |
|
228 | 227 | self.shell.run_code("first = MyClass(5)") |
|
229 | 228 | self.shell.run_code("first.square()") |
|
230 |
with |
|
|
229 | with self.assertRaises(AttributeError): | |
|
231 | 230 | self.shell.run_code("first.cube()") |
|
232 |
with |
|
|
231 | with self.assertRaises(AttributeError): | |
|
233 | 232 | self.shell.run_code("first.power(5)") |
|
234 | 233 | self.shell.run_code("first.b") |
|
235 |
with |
|
|
234 | with self.assertRaises(AttributeError): | |
|
236 | 235 | self.shell.run_code("first.toto") |
|
237 | 236 | |
|
238 | 237 | # remove square, add power |
@@ -258,13 +257,13 b' class TestAutoreload(Fixture):' | |||
|
258 | 257 | |
|
259 | 258 | for object_name in {"first", "second"}: |
|
260 | 259 | self.shell.run_code(f"{object_name}.power(5)") |
|
261 |
with |
|
|
260 | with self.assertRaises(AttributeError): | |
|
262 | 261 | self.shell.run_code(f"{object_name}.cube()") |
|
263 |
with |
|
|
262 | with self.assertRaises(AttributeError): | |
|
264 | 263 | self.shell.run_code(f"{object_name}.square()") |
|
265 | 264 | self.shell.run_code(f"{object_name}.b") |
|
266 | 265 | self.shell.run_code(f"{object_name}.a") |
|
267 |
with |
|
|
266 | with self.assertRaises(AttributeError): | |
|
268 | 267 | self.shell.run_code(f"{object_name}.toto") |
|
269 | 268 | |
|
270 | 269 | def test_autoload_newly_added_objects(self): |
@@ -275,11 +274,11 b' class TestAutoreload(Fixture):' | |||
|
275 | 274 | mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code)) |
|
276 | 275 | self.shell.run_code(f"from {mod_name} import *") |
|
277 | 276 | self.shell.run_code("func1()") |
|
278 |
with |
|
|
277 | with self.assertRaises(NameError): | |
|
279 | 278 | self.shell.run_code("func2()") |
|
280 |
with |
|
|
279 | with self.assertRaises(NameError): | |
|
281 | 280 | self.shell.run_code("t = Test()") |
|
282 |
with |
|
|
281 | with self.assertRaises(NameError): | |
|
283 | 282 | self.shell.run_code("number") |
|
284 | 283 | |
|
285 | 284 | # ----------- TEST NEW OBJ LOADED -------------------------- |
@@ -391,19 +390,19 b" class Bar: # old-style class: weakref doesn't work for it on Python < 2.7" | |||
|
391 | 390 | self.shell.magic_aimport(mod_name) |
|
392 | 391 | stream = StringIO() |
|
393 | 392 | self.shell.magic_aimport("", stream=stream) |
|
394 |
|
|
|
393 | self.assertIn(("Modules to reload:\n%s" % mod_name), stream.getvalue()) | |
|
395 | 394 | |
|
396 |
with |
|
|
395 | with self.assertRaises(ImportError): | |
|
397 | 396 | self.shell.magic_aimport("tmpmod_as318989e89ds") |
|
398 | 397 | else: |
|
399 | 398 | self.shell.magic_autoreload("2") |
|
400 | 399 | self.shell.run_code("import %s" % mod_name) |
|
401 | 400 | stream = StringIO() |
|
402 | 401 | self.shell.magic_aimport("", stream=stream) |
|
403 |
|
|
|
402 | self.assertTrue( | |
|
404 | 403 | "Modules to reload:\nall-except-skipped" in stream.getvalue() |
|
405 | 404 | ) |
|
406 |
|
|
|
405 | self.assertIn(mod_name, self.shell.ns) | |
|
407 | 406 | |
|
408 | 407 | mod = sys.modules[mod_name] |
|
409 | 408 | |
@@ -415,21 +414,21 b" class Bar: # old-style class: weakref doesn't work for it on Python < 2.7" | |||
|
415 | 414 | old_obj2 = mod.Bar() |
|
416 | 415 | |
|
417 | 416 | def check_module_contents(): |
|
418 |
|
|
|
419 |
|
|
|
417 | self.assertEqual(mod.x, 9) | |
|
418 | self.assertEqual(mod.z, 123) | |
|
420 | 419 | |
|
421 |
|
|
|
422 |
|
|
|
420 | self.assertEqual(old_foo(0), 3) | |
|
421 | self.assertEqual(mod.foo(0), 3) | |
|
423 | 422 | |
|
424 | 423 | obj = mod.Baz(9) |
|
425 |
|
|
|
426 |
|
|
|
427 |
|
|
|
428 |
|
|
|
424 | self.assertEqual(old_obj.bar(1), 10) | |
|
425 | self.assertEqual(obj.bar(1), 10) | |
|
426 | self.assertEqual(obj.quux, 42) | |
|
427 | self.assertEqual(obj.zzz(), 99) | |
|
429 | 428 | |
|
430 | 429 | obj2 = mod.Bar() |
|
431 |
|
|
|
432 |
|
|
|
430 | self.assertEqual(old_obj2.foo(), 1) | |
|
431 | self.assertEqual(obj2.foo(), 1) | |
|
433 | 432 | |
|
434 | 433 | check_module_contents() |
|
435 | 434 | |
@@ -481,25 +480,25 b' class Bar: # old-style class' | |||
|
481 | 480 | ) |
|
482 | 481 | |
|
483 | 482 | def check_module_contents(): |
|
484 |
|
|
|
485 |
|
|
|
483 | self.assertEqual(mod.x, 10) | |
|
484 | self.assertFalse(hasattr(mod, "z")) | |
|
486 | 485 | |
|
487 |
|
|
|
488 |
|
|
|
486 | self.assertEqual(old_foo(0), 4) # superreload magic! | |
|
487 | self.assertEqual(mod.foo(0), 4) | |
|
489 | 488 | |
|
490 | 489 | obj = mod.Baz(9) |
|
491 |
|
|
|
492 |
|
|
|
490 | self.assertEqual(old_obj.bar(1), 11) # superreload magic! | |
|
491 | self.assertEqual(obj.bar(1), 11) | |
|
493 | 492 | |
|
494 |
|
|
|
495 |
|
|
|
493 | self.assertEqual(old_obj.quux, 43) | |
|
494 | self.assertEqual(obj.quux, 43) | |
|
496 | 495 | |
|
497 |
|
|
|
498 |
|
|
|
496 | self.assertFalse(hasattr(old_obj, "zzz")) | |
|
497 | self.assertFalse(hasattr(obj, "zzz")) | |
|
499 | 498 | |
|
500 | 499 | obj2 = mod.Bar() |
|
501 |
|
|
|
502 |
|
|
|
500 | self.assertEqual(old_obj2.foo(), 2) | |
|
501 | self.assertEqual(obj2.foo(), 2) | |
|
503 | 502 | |
|
504 | 503 | self.shell.run_code("pass") # trigger reload |
|
505 | 504 | check_module_contents() |
@@ -519,7 +518,7 b' class Bar: # old-style class' | |||
|
519 | 518 | self.shell.magic_aimport("-" + mod_name) |
|
520 | 519 | stream = StringIO() |
|
521 | 520 | self.shell.magic_aimport("", stream=stream) |
|
522 |
|
|
|
521 | self.assertTrue(("Modules to skip:\n%s" % mod_name) in stream.getvalue()) | |
|
523 | 522 | |
|
524 | 523 | # This should succeed, although no such module exists |
|
525 | 524 | self.shell.magic_aimport("-tmpmod_as318989e89ds") |
@@ -546,7 +545,7 b' x = -99' | |||
|
546 | 545 | self.shell.magic_autoreload("") |
|
547 | 546 | |
|
548 | 547 | self.shell.run_code("pass") # trigger reload |
|
549 |
|
|
|
548 | self.assertEqual(mod.x, -99) | |
|
550 | 549 | |
|
551 | 550 | def test_smoketest_aimport(self): |
|
552 | 551 | self._check_smoketest(use_aimport=True) |
@@ -1,7 +1,6 b'' | |||
|
1 | 1 | import tempfile, os |
|
2 | 2 | |
|
3 | 3 | from traitlets.config.loader import Config |
|
4 | import nose.tools as nt | |
|
5 | 4 | |
|
6 | 5 | |
|
7 | 6 | def setup_module(): |
@@ -23,10 +22,10 b' def test_store_restore():' | |||
|
23 | 22 | ip.magic('store foobar foobaz') |
|
24 | 23 | |
|
25 | 24 | # Check storing |
|
26 |
|
|
|
27 |
|
|
|
28 |
|
|
|
29 |
|
|
|
25 | assert ip.db["autorestore/foo"] == 78 | |
|
26 | assert "bar" in ip.db["stored_aliases"] | |
|
27 | assert ip.db["autorestore/foobar"] == 79 | |
|
28 | assert ip.db["autorestore/foobaz"] == "80" | |
|
30 | 29 | |
|
31 | 30 | # Remove those items |
|
32 | 31 | ip.user_ns.pop('foo', None) |
@@ -37,14 +36,14 b' def test_store_restore():' | |||
|
37 | 36 | ip.user_ns['_dh'][:] = [] |
|
38 | 37 | |
|
39 | 38 | # Check restoring |
|
40 |
ip.magic( |
|
|
41 |
|
|
|
42 |
assert ip.alias_manager.is_alias( |
|
|
43 |
|
|
|
44 |
|
|
|
39 | ip.magic("store -r foo bar foobar foobaz") | |
|
40 | assert ip.user_ns["foo"] == 78 | |
|
41 | assert ip.alias_manager.is_alias("bar") | |
|
42 | assert ip.user_ns["foobar"] == 79 | |
|
43 | assert ip.user_ns["foobaz"] == "80" | |
|
45 | 44 | |
|
46 |
ip.magic( |
|
|
47 |
|
|
|
45 | ip.magic("store -r") # restores _dh too | |
|
46 | assert os.path.realpath(tmpd) in ip.user_ns["_dh"] | |
|
48 | 47 | |
|
49 | 48 | os.rmdir(tmpd) |
|
50 | 49 | |
@@ -57,10 +56,10 b' def test_autorestore():' | |||
|
57 | 56 | orig_config = ip.config |
|
58 | 57 | try: |
|
59 | 58 | ip.config = c |
|
60 |
ip.extension_manager.reload_extension( |
|
|
61 |
|
|
|
59 | ip.extension_manager.reload_extension("storemagic") | |
|
60 | assert "foo" not in ip.user_ns | |
|
62 | 61 | c.StoreMagics.autorestore = True |
|
63 |
ip.extension_manager.reload_extension( |
|
|
64 |
|
|
|
62 | ip.extension_manager.reload_extension("storemagic") | |
|
63 | assert ip.user_ns["foo"] == 95 | |
|
65 | 64 | finally: |
|
66 | 65 | ip.config = orig_config |
@@ -1,5 +1,3 b'' | |||
|
1 | import nose.tools as nt | |
|
2 | ||
|
3 | 1 |
|
|
4 | 2 | from IPython.lib.clipboard import ClipboardEmpty |
|
5 | 3 | from IPython.testing.decorators import skip_if_no_x11 |
@@ -18,4 +16,4 b' def test_clipboard_get():' | |||
|
18 | 16 | # No clipboard access API available |
|
19 | 17 | pass |
|
20 | 18 | else: |
|
21 |
|
|
|
19 | assert isinstance(a, str) |
@@ -6,8 +6,6 b'' | |||
|
6 | 6 | |
|
7 | 7 | from pathlib import Path |
|
8 | 8 | |
|
9 | import nose.tools as nt | |
|
10 | ||
|
11 | 9 | from IPython.utils.syspathcontext import prepended_to_syspath |
|
12 | 10 | from IPython.utils.tempdir import TemporaryDirectory |
|
13 | 11 | from IPython.lib.deepreload import reload as dreload |
@@ -28,9 +26,9 b' def test_deepreload():' | |||
|
28 | 26 | # Test that A is not reloaded. |
|
29 | 27 | obj = A.Object() |
|
30 | 28 | dreload(B, exclude=["A"]) |
|
31 |
|
|
|
29 | assert isinstance(obj, A.Object) is True | |
|
32 | 30 | |
|
33 | 31 | # Test that A is reloaded. |
|
34 | 32 | obj = A.Object() |
|
35 | 33 | dreload(B) |
|
36 |
|
|
|
34 | assert isinstance(obj, A.Object) is False |
@@ -21,7 +21,7 b' import wave' | |||
|
21 | 21 | from io import BytesIO |
|
22 | 22 | |
|
23 | 23 | # Third-party imports |
|
24 | import nose.tools as nt | |
|
24 | import pytest | |
|
25 | 25 | |
|
26 | 26 | try: |
|
27 | 27 | import numpy |
@@ -48,10 +48,10 b' def test_instantiation_FileLink():' | |||
|
48 | 48 | fl = display.FileLink(pathlib.PurePath('example.txt')) |
|
49 | 49 | |
|
50 | 50 | def test_warning_on_non_existent_path_FileLink(): |
|
51 | """FileLink: Calling _repr_html_ on non-existent files returns a warning | |
|
52 | """ | |
|
53 | fl = display.FileLink('example.txt') | |
|
54 | nt.assert_true(fl._repr_html_().startswith('Path (<tt>example.txt</tt>)')) | |
|
51 | """FileLink: Calling _repr_html_ on non-existent files returns a warning""" | |
|
52 | fl = display.FileLink("example.txt") | |
|
53 | assert fl._repr_html_().startswith("Path (<tt>example.txt</tt>)") | |
|
54 | ||
|
55 | 55 | |
|
56 | 56 | def test_existing_path_FileLink(): |
|
57 | 57 | """FileLink: Calling _repr_html_ functions as expected on existing filepath |
@@ -77,7 +77,7 b' def test_error_on_directory_to_FileLink():' | |||
|
77 | 77 | """FileLink: Raises error when passed directory |
|
78 | 78 | """ |
|
79 | 79 | td = mkdtemp() |
|
80 |
|
|
|
80 | pytest.raises(ValueError, display.FileLink, td) | |
|
81 | 81 | |
|
82 | 82 | #-------------------------- |
|
83 | 83 | # FileLinks tests |
@@ -89,10 +89,10 b' def test_instantiation_FileLinks():' | |||
|
89 | 89 | fls = display.FileLinks('example') |
|
90 | 90 | |
|
91 | 91 | def test_warning_on_non_existent_path_FileLinks(): |
|
92 | """FileLinks: Calling _repr_html_ on non-existent files returns a warning | |
|
93 | """ | |
|
94 | fls = display.FileLinks('example') | |
|
95 | nt.assert_true(fls._repr_html_().startswith('Path (<tt>example</tt>)')) | |
|
92 | """FileLinks: Calling _repr_html_ on non-existent files returns a warning""" | |
|
93 | fls = display.FileLinks("example") | |
|
94 | assert fls._repr_html_().startswith("Path (<tt>example</tt>)") | |
|
95 | ||
|
96 | 96 | |
|
97 | 97 | def test_existing_path_FileLinks(): |
|
98 | 98 | """FileLinks: Calling _repr_html_ functions as expected on existing dir |
@@ -172,7 +172,8 b' def test_error_on_file_to_FileLinks():' | |||
|
172 | 172 | """ |
|
173 | 173 | td = mkdtemp() |
|
174 | 174 | tf1 = NamedTemporaryFile(dir=td) |
|
175 |
|
|
|
175 | pytest.raises(ValueError, display.FileLinks, tf1.name) | |
|
176 | ||
|
176 | 177 | |
|
177 | 178 | def test_recursive_FileLinks(): |
|
178 | 179 | """FileLinks: Does not recurse when recursive=False |
@@ -210,7 +211,7 b' class TestAudioDataWithNumpy(TestCase):' | |||
|
210 | 211 | |
|
211 | 212 | @skipif_not_numpy |
|
212 | 213 | def test_audio_from_numpy_array_without_rate_raises(self): |
|
213 |
|
|
|
214 | self.assertRaises(ValueError, display.Audio, get_test_tone()) | |
|
214 | 215 | |
|
215 | 216 | @skipif_not_numpy |
|
216 | 217 | def test_audio_data_normalization(self): |
@@ -232,10 +233,10 b' class TestAudioDataWithNumpy(TestCase):' | |||
|
232 | 233 | assert actual_max_value == expected_max_value |
|
233 | 234 | |
|
234 | 235 | def test_audio_data_without_normalization_raises_for_invalid_data(self): |
|
235 |
|
|
|
236 | self.assertRaises( | |
|
236 | 237 | ValueError, |
|
237 | 238 | lambda: display.Audio([1.001], rate=44100, normalize=False)) |
|
238 |
|
|
|
239 | self.assertRaises( | |
|
239 | 240 | ValueError, |
|
240 | 241 | lambda: display.Audio([-1.001], rate=44100, normalize=False)) |
|
241 | 242 | |
@@ -253,9 +254,8 b' class TestAudioDataWithoutNumpy(TestAudioDataWithNumpy):' | |||
|
253 | 254 | @skipif_not_numpy |
|
254 | 255 | def test_audio_raises_for_nested_list(self): |
|
255 | 256 | stereo_signal = [list(get_test_tone())] * 2 |
|
256 | nt.assert_raises( | |
|
257 | TypeError, | |
|
258 | lambda: display.Audio(stereo_signal, rate=44100)) | |
|
257 | self.assertRaises(TypeError, lambda: display.Audio(stereo_signal, rate=44100)) | |
|
258 | ||
|
259 | 259 | |
|
260 | 260 | @skipif_not_numpy |
|
261 | 261 | def get_test_tone(scale=1): |
@@ -5,7 +5,6 b'' | |||
|
5 | 5 | from contextlib import contextmanager |
|
6 | 6 | from unittest.mock import patch |
|
7 | 7 | |
|
8 | import nose.tools as nt | |
|
9 | 8 | import pytest |
|
10 | 9 | |
|
11 | 10 | from IPython.lib import latextools |
@@ -185,7 +184,13 b' def test_latex_to_png_invalid_hex_colors():' | |||
|
185 | 184 | Test that invalid hex colors provided to dvipng gives an exception. |
|
186 | 185 | """ |
|
187 | 186 | latex_string = "$x^2$" |
|
188 | nt.assert_raises(ValueError, lambda: latextools.latex_to_png(latex_string, | |
|
189 | backend='dvipng', color="#f00bar")) | |
|
190 |
|
|
|
191 |
|
|
|
187 | pytest.raises( | |
|
188 | ValueError, | |
|
189 | lambda: latextools.latex_to_png( | |
|
190 | latex_string, backend="dvipng", color="#f00bar" | |
|
191 | ), | |
|
192 | ) | |
|
193 | pytest.raises( | |
|
194 | ValueError, | |
|
195 | lambda: latextools.latex_to_png(latex_string, backend="dvipng", color="#f00"), | |
|
196 | ) |
@@ -11,7 +11,6 b' import types' | |||
|
11 | 11 | import string |
|
12 | 12 | import unittest |
|
13 | 13 | |
|
14 | import nose.tools as nt | |
|
15 | 14 | import pytest |
|
16 | 15 | |
|
17 | 16 | from IPython.lib import pretty |
@@ -70,7 +69,6 b' class BreakingRepr(object):' | |||
|
70 | 69 | return "Breaking(\n)" |
|
71 | 70 | |
|
72 | 71 | class BadRepr(object): |
|
73 | ||
|
74 | 72 | def __repr__(self): |
|
75 | 73 | return 1/0 |
|
76 | 74 | |
@@ -178,7 +176,7 b' def test_pprint_break_repr():' | |||
|
178 | 176 | |
|
179 | 177 | def test_bad_repr(): |
|
180 | 178 | """Don't catch bad repr errors""" |
|
181 |
with |
|
|
179 | with pytest.raises(ZeroDivisionError): | |
|
182 | 180 | pretty.pretty(BadRepr()) |
|
183 | 181 | |
|
184 | 182 | class BadException(Exception): |
@@ -190,12 +188,12 b' class ReallyBadRepr(object):' | |||
|
190 | 188 | @property |
|
191 | 189 | def __class__(self): |
|
192 | 190 | raise ValueError("I am horrible") |
|
193 | ||
|
191 | ||
|
194 | 192 | def __repr__(self): |
|
195 | 193 | raise BadException() |
|
196 | 194 | |
|
197 | 195 | def test_really_bad_repr(): |
|
198 |
with |
|
|
196 | with pytest.raises(BadException): | |
|
199 | 197 | pretty.pretty(ReallyBadRepr()) |
|
200 | 198 | |
|
201 | 199 | |
@@ -266,11 +264,11 b' def test_metaclass_repr():' | |||
|
266 | 264 | def test_unicode_repr(): |
|
267 | 265 | u = u"üniçodé" |
|
268 | 266 | ustr = u |
|
269 | ||
|
267 | ||
|
270 | 268 | class C(object): |
|
271 | 269 | def __repr__(self): |
|
272 | 270 | return ustr |
|
273 | ||
|
271 | ||
|
274 | 272 | c = C() |
|
275 | 273 | p = pretty.pretty(c) |
|
276 | 274 | assert p == u |
@@ -293,7 +291,7 b' def test_basic_class():' | |||
|
293 | 291 | output = stream.getvalue() |
|
294 | 292 | |
|
295 | 293 | assert output == "%s.MyObj" % __name__ |
|
296 |
|
|
|
294 | assert type_pprint_wrapper.called is True | |
|
297 | 295 | |
|
298 | 296 | |
|
299 | 297 | # TODO : pytest.mark.parametrise once nose is gone. |
@@ -478,7 +476,7 b' def test_function_pretty():' | |||
|
478 | 476 | return 42 |
|
479 | 477 | return "Don't panic" |
|
480 | 478 | |
|
481 |
|
|
|
479 | assert "meaning_of_life(question=None)" in pretty.pretty(meaning_of_life) | |
|
482 | 480 | |
|
483 | 481 | |
|
484 | 482 | class OrderedCounter(Counter, OrderedDict): |
@@ -497,6 +495,6 b' class MySet(set): # Override repr of a basic type' | |||
|
497 | 495 | def test_custom_repr(): |
|
498 | 496 | """A custom repr should override a pretty printer for a parent type""" |
|
499 | 497 | oc = OrderedCounter("abracadabra") |
|
500 |
|
|
|
498 | assert "OrderedCounter(OrderedDict" in pretty.pretty(oc) | |
|
501 | 499 | |
|
502 | 500 | assert pretty.pretty(MySet()) == "mine" |
@@ -14,7 +14,7 b'' | |||
|
14 | 14 | import os |
|
15 | 15 | import subprocess |
|
16 | 16 | import sys |
|
17 | import nose.tools as nt | |
|
17 | ||
|
18 | 18 | from IPython.utils.tempdir import NamedFileInTemporaryDirectory |
|
19 | 19 | from IPython.testing.decorators import skip_win32 |
|
20 | 20 | from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE |
@@ -55,12 +55,13 b' def test_ipython_embed():' | |||
|
55 | 55 | out, err = p.communicate(_exit) |
|
56 | 56 | std = out.decode('UTF-8') |
|
57 | 57 | |
|
58 |
|
|
|
59 |
|
|
|
60 |
if os.name != |
|
|
58 | assert p.returncode == 0 | |
|
59 | assert "3 . 14" in std | |
|
60 | if os.name != "nt": | |
|
61 | 61 | # TODO: Fix up our different stdout references, see issue gh-14 |
|
62 |
|
|
|
63 |
|
|
|
62 | assert "IPython" in std | |
|
63 | assert "bye!" in std | |
|
64 | ||
|
64 | 65 | |
|
65 | 66 | @skip_win32 |
|
66 | 67 | def test_nest_embed(): |
@@ -12,29 +12,42 b' from IPython.testing import tools as tt' | |||
|
12 | 12 | from IPython.utils.capture import capture_output |
|
13 | 13 | |
|
14 | 14 | from IPython.terminal.ptutils import _elide, _adjust_completion_text_based_on_context |
|
15 | import nose.tools as nt | |
|
16 | 15 | |
|
17 | class TestElide(unittest.TestCase): | |
|
18 | 16 | |
|
17 | class TestElide(unittest.TestCase): | |
|
19 | 18 | def test_elide(self): |
|
20 |
_elide( |
|
|
21 |
_elide( |
|
|
22 | nt.assert_equal(_elide('aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh',''), 'aaaa.b…g.hhhhhh') | |
|
23 | ||
|
24 | test_string = os.sep.join(['', 10*'a', 10*'b', 10*'c', '']) | |
|
25 | expect_stirng = os.sep + 'a' + '\N{HORIZONTAL ELLIPSIS}' + 'b' + os.sep + 10*'c' | |
|
26 | nt.assert_equal(_elide(test_string, ''), expect_stirng) | |
|
19 | _elide("concatenate((a1, a2, ...), axis", "") # do not raise | |
|
20 | _elide("concatenate((a1, a2, ..), . axis", "") # do not raise | |
|
21 | self.assertEqual( | |
|
22 | _elide("aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh", ""), | |
|
23 | "aaaa.b…g.hhhhhh", | |
|
24 | ) | |
|
25 | ||
|
26 | test_string = os.sep.join(["", 10 * "a", 10 * "b", 10 * "c", ""]) | |
|
27 | expect_stirng = ( | |
|
28 | os.sep + "a" + "\N{HORIZONTAL ELLIPSIS}" + "b" + os.sep + 10 * "c" | |
|
29 | ) | |
|
30 | self.assertEqual(_elide(test_string, ""), expect_stirng) | |
|
27 | 31 | |
|
28 | 32 | def test_elide_typed_normal(self): |
|
29 | nt.assert_equal(_elide('the quick brown fox jumped over the lazy dog', 'the quick brown fox', min_elide=10), 'the…fox jumped over the lazy dog') | |
|
30 | ||
|
33 | self.assertEqual( | |
|
34 | _elide( | |
|
35 | "the quick brown fox jumped over the lazy dog", | |
|
36 | "the quick brown fox", | |
|
37 | min_elide=10, | |
|
38 | ), | |
|
39 | "the…fox jumped over the lazy dog", | |
|
40 | ) | |
|
31 | 41 | |
|
32 | 42 | def test_elide_typed_short_match(self): |
|
33 | 43 | """ |
|
34 | 44 | if the match is too short we don't elide. |
|
35 | 45 | avoid the "the...the" |
|
36 | 46 | """ |
|
37 | nt.assert_equal(_elide('the quick brown fox jumped over the lazy dog', 'the', min_elide=10), 'the quick brown fox jumped over the lazy dog') | |
|
47 | self.assertEqual( | |
|
48 | _elide("the quick brown fox jumped over the lazy dog", "the", min_elide=10), | |
|
49 | "the quick brown fox jumped over the lazy dog", | |
|
50 | ) | |
|
38 | 51 | |
|
39 | 52 | def test_elide_typed_no_match(self): |
|
40 | 53 | """ |
@@ -42,22 +55,41 b' class TestElide(unittest.TestCase):' | |||
|
42 | 55 | avoid the "the...the" |
|
43 | 56 | """ |
|
44 | 57 | # here we typed red instead of brown |
|
45 | nt.assert_equal(_elide('the quick brown fox jumped over the lazy dog', 'the quick red fox', min_elide=10), 'the quick brown fox jumped over the lazy dog') | |
|
58 | self.assertEqual( | |
|
59 | _elide( | |
|
60 | "the quick brown fox jumped over the lazy dog", | |
|
61 | "the quick red fox", | |
|
62 | min_elide=10, | |
|
63 | ), | |
|
64 | "the quick brown fox jumped over the lazy dog", | |
|
65 | ) | |
|
46 | 66 | |
|
47 | class TestContextAwareCompletion(unittest.TestCase): | |
|
48 | 67 | |
|
68 | class TestContextAwareCompletion(unittest.TestCase): | |
|
49 | 69 | def test_adjust_completion_text_based_on_context(self): |
|
50 | 70 | # Adjusted case |
|
51 | nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a=)', 7), 'arg1') | |
|
71 | self.assertEqual( | |
|
72 | _adjust_completion_text_based_on_context("arg1=", "func1(a=)", 7), "arg1" | |
|
73 | ) | |
|
52 | 74 | |
|
53 | 75 | # Untouched cases |
|
54 | nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a)', 7), 'arg1=') | |
|
55 |
|
|
|
56 | nt.assert_equal(_adjust_completion_text_based_on_context('%magic', 'func1(a=)', 7), '%magic') | |
|
57 | nt.assert_equal(_adjust_completion_text_based_on_context('func2', 'func1(a=)', 7), 'func2') | |
|
76 | self.assertEqual( | |
|
77 | _adjust_completion_text_based_on_context("arg1=", "func1(a)", 7), "arg1=" | |
|
78 | ) | |
|
79 | self.assertEqual( | |
|
80 | _adjust_completion_text_based_on_context("arg1=", "func1(a", 7), "arg1=" | |
|
81 | ) | |
|
82 | self.assertEqual( | |
|
83 | _adjust_completion_text_based_on_context("%magic", "func1(a=)", 7), "%magic" | |
|
84 | ) | |
|
85 | self.assertEqual( | |
|
86 | _adjust_completion_text_based_on_context("func2", "func1(a=)", 7), "func2" | |
|
87 | ) | |
|
88 | ||
|
58 | 89 | |
|
59 | 90 | # Decorator for interaction loop tests ----------------------------------------- |
|
60 | 91 | |
|
92 | ||
|
61 | 93 | class mock_input_helper(object): |
|
62 | 94 | """Machinery for tests of the main interact loop. |
|
63 | 95 |
@@ -6,9 +6,6 b'' | |||
|
6 | 6 | import inspect |
|
7 | 7 | import sys |
|
8 | 8 | |
|
9 | # Third party | |
|
10 | import nose.tools as nt | |
|
11 | ||
|
12 | 9 | # Our own |
|
13 | 10 | from IPython.testing import decorators as dec |
|
14 | 11 | from IPython.testing.skipdoctest import skip_doctest |
@@ -95,7 +92,7 b' def test_skip_dt_decorator():' | |||
|
95 | 92 | # Fetch the docstring from doctest_bad after decoration. |
|
96 | 93 | val = doctest_bad.__doc__ |
|
97 | 94 | |
|
98 |
|
|
|
95 | assert check == val, "doctest_bad docstrings don't match" | |
|
99 | 96 | |
|
100 | 97 | |
|
101 | 98 | # Doctest skipping should work for class methods too |
@@ -156,13 +153,14 b' def test_skip_dt_decorator2():' | |||
|
156 | 153 | |
|
157 | 154 | @dec.skip_linux |
|
158 | 155 | def test_linux(): |
|
159 |
|
|
|
156 | assert sys.platform.startswith("linux") is False, "This test can't run under linux" | |
|
157 | ||
|
160 | 158 | |
|
161 | 159 | @dec.skip_win32 |
|
162 | 160 | def test_win32(): |
|
163 |
|
|
|
161 | assert sys.platform != "win32", "This test can't run under windows" | |
|
162 | ||
|
164 | 163 | |
|
165 | 164 | @dec.skip_osx |
|
166 | 165 | def test_osx(): |
|
167 |
|
|
|
168 | ||
|
166 | assert sys.platform != "darwin", "This test can't run under osx" |
@@ -17,8 +17,6 b' Tests for testing.tools' | |||
|
17 | 17 | import os |
|
18 | 18 | import unittest |
|
19 | 19 | |
|
20 | import nose.tools as nt | |
|
21 | ||
|
22 | 20 | from IPython.testing import decorators as dec |
|
23 | 21 | from IPython.testing import tools as tt |
|
24 | 22 | |
@@ -28,26 +26,26 b' from IPython.testing import tools as tt' | |||
|
28 | 26 | |
|
29 | 27 | @dec.skip_win32 |
|
30 | 28 | def test_full_path_posix(): |
|
31 |
spath = |
|
|
32 |
result = tt.full_path(spath,[ |
|
|
33 |
|
|
|
34 |
spath = |
|
|
35 |
result = tt.full_path(spath,[ |
|
|
36 |
|
|
|
37 |
result = tt.full_path(spath, |
|
|
38 |
|
|
|
29 | spath = "/foo/bar.py" | |
|
30 | result = tt.full_path(spath, ["a.txt", "b.txt"]) | |
|
31 | assert result, ["/foo/a.txt" == "/foo/b.txt"] | |
|
32 | spath = "/foo" | |
|
33 | result = tt.full_path(spath, ["a.txt", "b.txt"]) | |
|
34 | assert result, ["/a.txt" == "/b.txt"] | |
|
35 | result = tt.full_path(spath, "a.txt") | |
|
36 | assert result == ["/a.txt"] | |
|
39 | 37 | |
|
40 | 38 | |
|
41 | 39 | @dec.skip_if_not_win32 |
|
42 | 40 | def test_full_path_win32(): |
|
43 |
spath = |
|
|
44 |
result = tt.full_path(spath,[ |
|
|
45 |
|
|
|
46 |
spath = |
|
|
47 |
result = tt.full_path(spath,[ |
|
|
48 |
|
|
|
49 |
result = tt.full_path(spath, |
|
|
50 |
|
|
|
41 | spath = "c:\\foo\\bar.py" | |
|
42 | result = tt.full_path(spath, ["a.txt", "b.txt"]) | |
|
43 | assert result, ["c:\\foo\\a.txt" == "c:\\foo\\b.txt"] | |
|
44 | spath = "c:\\foo" | |
|
45 | result = tt.full_path(spath, ["a.txt", "b.txt"]) | |
|
46 | assert result, ["c:\\a.txt" == "c:\\b.txt"] | |
|
47 | result = tt.full_path(spath, "a.txt") | |
|
48 | assert result == ["c:\\a.txt"] | |
|
51 | 49 | |
|
52 | 50 | |
|
53 | 51 | def test_parser(): |
@@ -56,8 +54,8 b' def test_parser():' | |||
|
56 | 54 | both = ("FAILED (errors=1, failures=1)", 1, 1) |
|
57 | 55 | for txt, nerr, nfail in [err, fail, both]: |
|
58 | 56 | nerr1, nfail1 = tt.parse_test_output(txt) |
|
59 |
|
|
|
60 |
|
|
|
57 | assert nerr == nerr1 | |
|
58 | assert nfail == nfail1 | |
|
61 | 59 | |
|
62 | 60 | |
|
63 | 61 | def test_temp_pyfile(): |
@@ -66,7 +64,7 b' def test_temp_pyfile():' | |||
|
66 | 64 | assert os.path.isfile(fname) |
|
67 | 65 | with open(fname) as fh2: |
|
68 | 66 | src2 = fh2.read() |
|
69 |
|
|
|
67 | assert src2 == src | |
|
70 | 68 | |
|
71 | 69 | class TestAssertPrints(unittest.TestCase): |
|
72 | 70 | def test_passing(self): |
@@ -1,6 +1,7 b'' | |||
|
1 | import nose.tools as nt | |
|
2 | 1 |
|
|
3 | 2 | |
|
3 | import pytest | |
|
4 | ||
|
4 | 5 | |
|
5 | 6 | class Base(object): |
|
6 | 7 | x = 1 |
@@ -9,12 +10,13 b' class Base(object):' | |||
|
9 | 10 | |
|
10 | 11 | def test_base(): |
|
11 | 12 | res = dir2(Base()) |
|
12 |
assert |
|
|
13 |
assert |
|
|
14 |
assert |
|
|
15 |
assert |
|
|
16 |
|
|
|
17 |
|
|
|
13 | assert "x" in res | |
|
14 | assert "z" in res | |
|
15 | assert "y" not in res | |
|
16 | assert "__class__" in res | |
|
17 | assert res.count("x") == 1 | |
|
18 | assert res.count("__class__") == 1 | |
|
19 | ||
|
18 | 20 | |
|
19 | 21 | def test_SubClass(): |
|
20 | 22 | |
@@ -22,9 +24,9 b' def test_SubClass():' | |||
|
22 | 24 | y = 2 |
|
23 | 25 | |
|
24 | 26 | res = dir2(SubClass()) |
|
25 |
assert |
|
|
26 |
|
|
|
27 |
|
|
|
27 | assert "y" in res | |
|
28 | assert res.count("y") == 1 | |
|
29 | assert res.count("x") == 1 | |
|
28 | 30 | |
|
29 | 31 | |
|
30 | 32 | def test_SubClass_with_trait_names_attr(): |
@@ -35,24 +37,31 b' def test_SubClass_with_trait_names_attr():' | |||
|
35 | 37 | trait_names = 44 |
|
36 | 38 | |
|
37 | 39 | res = dir2(SubClass()) |
|
38 |
assert |
|
|
40 | assert "trait_names" in res | |
|
39 | 41 | |
|
40 | 42 | |
|
41 | 43 | def test_misbehaving_object_without_trait_names(): |
|
42 | 44 | # dir2 shouldn't raise even when objects are dumb and raise |
|
43 | 45 | # something other than AttribteErrors on bad getattr. |
|
44 | 46 | |
|
45 |
class MisbehavingGetattr |
|
|
46 | def __getattr__(self): | |
|
47 | class MisbehavingGetattr: | |
|
48 | def __getattr__(self, attr): | |
|
47 | 49 | raise KeyError("I should be caught") |
|
48 | 50 | |
|
49 | 51 | def some_method(self): |
|
50 |
|
|
|
52 | return True | |
|
51 | 53 | |
|
52 | 54 | class SillierWithDir(MisbehavingGetattr): |
|
53 | 55 | def __dir__(self): |
|
54 | 56 | return ['some_method'] |
|
55 | 57 | |
|
56 | 58 | for bad_klass in (MisbehavingGetattr, SillierWithDir): |
|
57 |
|
|
|
58 | assert('some_method' in res) | |
|
59 | obj = bad_klass() | |
|
60 | ||
|
61 | assert obj.some_method() | |
|
62 | ||
|
63 | with pytest.raises(KeyError): | |
|
64 | obj.other_method() | |
|
65 | ||
|
66 | res = dir2(obj) | |
|
67 | assert "some_method" in res |
@@ -11,7 +11,7 b'' | |||
|
11 | 11 | # Imports |
|
12 | 12 | #----------------------------------------------------------------------------- |
|
13 | 13 | |
|
14 | import nose.tools as nt | |
|
14 | import pytest | |
|
15 | 15 | |
|
16 | 16 | from IPython.utils.importstring import import_item |
|
17 | 17 | |
@@ -22,18 +22,19 b' from IPython.utils.importstring import import_item' | |||
|
22 | 22 | def test_import_plain(): |
|
23 | 23 | "Test simple imports" |
|
24 | 24 | import os |
|
25 | os2 = import_item('os') | |
|
26 | nt.assert_true(os is os2) | |
|
25 | ||
|
26 | os2 = import_item("os") | |
|
27 | assert os is os2 | |
|
27 | 28 | |
|
28 | 29 | |
|
29 | 30 | def test_import_nested(): |
|
30 | 31 | "Test nested imports from the stdlib" |
|
31 | 32 | from os import path |
|
32 | path2 = import_item('os.path') | |
|
33 | nt.assert_true(path is path2) | |
|
33 | ||
|
34 | path2 = import_item("os.path") | |
|
35 | assert path is path2 | |
|
34 | 36 | |
|
35 | 37 | |
|
36 | 38 | def test_import_raises(): |
|
37 | 39 | "Test that failing imports raise the right exception" |
|
38 |
|
|
|
39 | ||
|
40 | pytest.raises(ImportError, import_item, "IPython.foobar") |
@@ -11,8 +11,6 b' from io import StringIO' | |||
|
11 | 11 | from subprocess import Popen, PIPE |
|
12 | 12 | import unittest |
|
13 | 13 | |
|
14 | import nose.tools as nt | |
|
15 | ||
|
16 | 14 | from IPython.utils.io import IOStream, Tee, capture_output |
|
17 | 15 | |
|
18 | 16 | |
@@ -22,7 +20,7 b' def test_tee_simple():' | |||
|
22 | 20 | text = 'Hello' |
|
23 | 21 | tee = Tee(chan, channel='stdout') |
|
24 | 22 | print(text, file=chan) |
|
25 |
|
|
|
23 | assert chan.getvalue() == text + "\n" | |
|
26 | 24 | |
|
27 | 25 | |
|
28 | 26 | class TeeTestCase(unittest.TestCase): |
@@ -39,7 +37,7 b' class TeeTestCase(unittest.TestCase):' | |||
|
39 | 37 | |
|
40 | 38 | print(text, end='', file=chan) |
|
41 | 39 | trap_val = trap.getvalue() |
|
42 |
|
|
|
40 | self.assertEqual(chan.getvalue(), text) | |
|
43 | 41 | |
|
44 | 42 | tee.close() |
|
45 | 43 | |
@@ -82,8 +80,8 b' class TestIOStream(unittest.TestCase):' | |||
|
82 | 80 | """capture_output() context works""" |
|
83 | 81 | |
|
84 | 82 | with capture_output() as io: |
|
85 |
print( |
|
|
86 |
print( |
|
|
87 | ||
|
88 |
|
|
|
89 |
|
|
|
83 | print("hi, stdout") | |
|
84 | print("hi, stderr", file=sys.stderr) | |
|
85 | ||
|
86 | self.assertEqual(io.stdout, "hi, stdout\n") | |
|
87 | self.assertEqual(io.stderr, "hi, stderr\n") |
@@ -22,8 +22,6 b' from IPython.testing.tools import make_tempfile' | |||
|
22 | 22 | |
|
23 | 23 | import IPython.utils.module_paths as mp |
|
24 | 24 | |
|
25 | import nose.tools as nt | |
|
26 | ||
|
27 | 25 | TEST_FILE_PATH = Path(__file__).resolve().parent |
|
28 | 26 | |
|
29 | 27 | TMP_TEST_DIR = Path(tempfile.mkdtemp(suffix="with.dot")) |
@@ -67,7 +65,7 b' def test_tempdir():' | |||
|
67 | 65 | """ |
|
68 | 66 | Ensure the test are done with a temporary file that have a dot somewhere. |
|
69 | 67 | """ |
|
70 |
|
|
|
68 | assert "." in str(TMP_TEST_DIR) | |
|
71 | 69 | |
|
72 | 70 | |
|
73 | 71 | def test_find_mod_1(): |
@@ -76,7 +74,7 b' def test_find_mod_1():' | |||
|
76 | 74 | Expected output: a path to that directory's __init__.py file. |
|
77 | 75 | """ |
|
78 | 76 | modpath = TMP_TEST_DIR / "xmod" / "__init__.py" |
|
79 |
|
|
|
77 | assert Path(mp.find_mod("xmod")) == modpath | |
|
80 | 78 | |
|
81 | 79 | def test_find_mod_2(): |
|
82 | 80 | """ |
@@ -85,7 +83,7 b' def test_find_mod_2():' | |||
|
85 | 83 | TODO: Confirm why this is a duplicate test. |
|
86 | 84 | """ |
|
87 | 85 | modpath = TMP_TEST_DIR / "xmod" / "__init__.py" |
|
88 |
|
|
|
86 | assert Path(mp.find_mod("xmod")) == modpath | |
|
89 | 87 | |
|
90 | 88 | def test_find_mod_3(): |
|
91 | 89 | """ |
@@ -93,7 +91,7 b' def test_find_mod_3():' | |||
|
93 | 91 | Expected output: full path with .py extension. |
|
94 | 92 | """ |
|
95 | 93 | modpath = TMP_TEST_DIR / "xmod" / "sub.py" |
|
96 |
|
|
|
94 | assert Path(mp.find_mod("xmod.sub")) == modpath | |
|
97 | 95 | |
|
98 | 96 | def test_find_mod_4(): |
|
99 | 97 | """ |
@@ -101,11 +99,11 b' def test_find_mod_4():' | |||
|
101 | 99 | Expected output: full path with .py extension |
|
102 | 100 | """ |
|
103 | 101 | modpath = TMP_TEST_DIR / "pack.py" |
|
104 |
|
|
|
102 | assert Path(mp.find_mod("pack")) == modpath | |
|
105 | 103 | |
|
106 | 104 | def test_find_mod_5(): |
|
107 | 105 | """ |
|
108 | 106 | Search for a filename with a .pyc extension |
|
109 | 107 | Expected output: TODO: do we exclude or include .pyc files? |
|
110 | 108 | """ |
|
111 |
|
|
|
109 | assert mp.find_mod("packpyc") == None |
@@ -1,6 +1,5 b'' | |||
|
1 | 1 | import io |
|
2 | 2 | import os.path |
|
3 | import nose.tools as nt | |
|
4 | 3 | |
|
5 | 4 | from IPython.utils import openpy |
|
6 | 5 | |
@@ -11,14 +10,14 b' nonascii_path = os.path.join(mydir, "../../core/tests/nonascii.py")' | |||
|
11 | 10 | def test_detect_encoding(): |
|
12 | 11 | with open(nonascii_path, "rb") as f: |
|
13 | 12 | enc, lines = openpy.detect_encoding(f.readline) |
|
14 |
|
|
|
13 | assert enc == "iso-8859-5" | |
|
15 | 14 | |
|
16 | 15 | |
|
17 | 16 | def test_read_file(): |
|
18 | 17 | with io.open(nonascii_path, encoding="iso-8859-5") as f: |
|
19 | 18 | read_specified_enc = f.read() |
|
20 | 19 | read_detected_enc = openpy.read_py_file(nonascii_path, skip_encoding_cookie=False) |
|
21 |
|
|
|
20 | assert read_detected_enc == read_specified_enc | |
|
22 | 21 | assert "coding: iso-8859-5" in read_detected_enc |
|
23 | 22 | |
|
24 | 23 | read_strip_enc_cookie = openpy.read_py_file( |
@@ -30,10 +29,10 b' def test_read_file():' | |||
|
30 | 29 | def test_source_to_unicode(): |
|
31 | 30 | with io.open(nonascii_path, "rb") as f: |
|
32 | 31 | source_bytes = f.read() |
|
33 |
|
|
|
34 |
openpy.source_to_unicode(source_bytes, skip_encoding_cookie=False).splitlines() |
|
|
35 |
source_bytes.decode("iso-8859-5").splitlines() |
|
|
32 | assert ( | |
|
33 | openpy.source_to_unicode(source_bytes, skip_encoding_cookie=False).splitlines() | |
|
34 | == source_bytes.decode("iso-8859-5").splitlines() | |
|
36 | 35 | ) |
|
37 | 36 | |
|
38 | 37 | source_no_cookie = openpy.source_to_unicode(source_bytes, skip_encoding_cookie=True) |
|
39 |
|
|
|
38 | assert "coding: iso-8859-5" not in source_no_cookie |
@@ -15,7 +15,7 b' from os.path import join, abspath' | |||
|
15 | 15 | from imp import reload |
|
16 | 16 | |
|
17 | 17 | from nose import SkipTest, with_setup |
|
18 | import nose.tools as nt | |
|
18 | import pytest | |
|
19 | 19 | |
|
20 | 20 | import IPython |
|
21 | 21 | from IPython import paths |
@@ -155,7 +155,7 b' def test_get_home_dir_5():' | |||
|
155 | 155 | env['HOME'] = abspath(HOME_TEST_DIR+'garbage') |
|
156 | 156 | # set os.name = posix, to prevent My Documents fallback on Windows |
|
157 | 157 | os.name = 'posix' |
|
158 |
|
|
|
158 | pytest.raises(path.HomeDirError, path.get_home_dir, True) | |
|
159 | 159 | |
|
160 | 160 | # Should we stub wreg fully so we can run the test on all platforms? |
|
161 | 161 | @skip_if_not_win32 |
@@ -237,8 +237,7 b' def test_get_xdg_dir_3():' | |||
|
237 | 237 | env.pop('IPYTHONDIR', None) |
|
238 | 238 | env.pop('XDG_CONFIG_HOME', None) |
|
239 | 239 | cfgdir=os.path.join(path.get_home_dir(), '.config') |
|
240 | if not os.path.exists(cfgdir): | |
|
241 | os.makedirs(cfgdir) | |
|
240 | os.makedirs(cfgdir, exist_ok=True) | |
|
242 | 241 | |
|
243 | 242 | assert path.get_xdg_dir() is None |
|
244 | 243 | |
@@ -305,15 +304,15 b' def test_get_py_filename():' | |||
|
305 | 304 | assert path.get_py_filename("foo") == "foo.py" |
|
306 | 305 | with make_tempfile("foo"): |
|
307 | 306 | assert path.get_py_filename("foo") == "foo" |
|
308 |
|
|
|
309 |
|
|
|
310 |
|
|
|
307 | pytest.raises(IOError, path.get_py_filename, "foo.py") | |
|
308 | pytest.raises(IOError, path.get_py_filename, "foo") | |
|
309 | pytest.raises(IOError, path.get_py_filename, "foo.py") | |
|
311 | 310 | true_fn = "foo with spaces.py" |
|
312 | 311 | with make_tempfile(true_fn): |
|
313 | 312 | assert path.get_py_filename("foo with spaces") == true_fn |
|
314 | 313 | assert path.get_py_filename("foo with spaces.py") == true_fn |
|
315 |
|
|
|
316 |
|
|
|
314 | pytest.raises(IOError, path.get_py_filename, '"foo with spaces.py"') | |
|
315 | pytest.raises(IOError, path.get_py_filename, "'foo with spaces.py'") | |
|
317 | 316 | |
|
318 | 317 | @onlyif_unicode_paths |
|
319 | 318 | def test_unicode_in_filename(): |
@@ -414,7 +413,7 b' def test_ensure_dir_exists():' | |||
|
414 | 413 | path.ensure_dir_exists(d) # no-op |
|
415 | 414 | f = os.path.join(td, 'ƒile') |
|
416 | 415 | open(f, 'w').close() # touch |
|
417 |
with |
|
|
416 | with pytest.raises(IOError): | |
|
418 | 417 | path.ensure_dir_exists(f) |
|
419 | 418 | |
|
420 | 419 | class TestLinkOrCopy(unittest.TestCase): |
@@ -20,9 +20,8 b' import os' | |||
|
20 | 20 | import time |
|
21 | 21 | from _thread import interrupt_main # Py 3 |
|
22 | 22 | import threading |
|
23 | from unittest import SkipTest | |
|
24 | 23 | |
|
25 | import nose.tools as nt | |
|
24 | import pytest | |
|
26 | 25 | |
|
27 | 26 | from IPython.utils.process import (find_cmd, FindCmdError, arg_split, |
|
28 | 27 | system, getoutput, getoutputerror, |
@@ -41,8 +40,8 b' python = os.path.basename(sys.executable)' | |||
|
41 | 40 | @dec.skip_win32 |
|
42 | 41 | def test_find_cmd_ls(): |
|
43 | 42 | """Make sure we can find the full path to ls.""" |
|
44 |
path = find_cmd( |
|
|
45 |
|
|
|
43 | path = find_cmd("ls") | |
|
44 | assert path.endswith("ls") | |
|
46 | 45 | |
|
47 | 46 | |
|
48 | 47 | def has_pywin32(): |
@@ -64,7 +63,7 b' def test_find_cmd_pythonw():' | |||
|
64 | 63 | "This test runs on posix or in win32 with win32api installed") |
|
65 | 64 | def test_find_cmd_fail(): |
|
66 | 65 | """Make sure that FindCmdError is raised if we can't find the cmd.""" |
|
67 |
|
|
|
66 | pytest.raises(FindCmdError, find_cmd, "asdfasdf") | |
|
68 | 67 | |
|
69 | 68 | |
|
70 | 69 | # TODO: move to pytest.mark.parametrize once nose gone |
@@ -121,7 +120,7 b' class SubProcessTestCase(tt.TempFileMixin):' | |||
|
121 | 120 | Interrupt a subprocess after a second. |
|
122 | 121 | """ |
|
123 | 122 | if threading.main_thread() != threading.current_thread(): |
|
124 |
raise |
|
|
123 | raise pytest.skip("Can't run this test if not in main thread.") | |
|
125 | 124 | |
|
126 | 125 | # Some tests can overwrite SIGINT handler (by using pdb for example), |
|
127 | 126 | # which then breaks this test, so just make sure it's operating |
@@ -17,9 +17,6 b' Authors' | |||
|
17 | 17 | # Imports |
|
18 | 18 | #----------------------------------------------------------------------------- |
|
19 | 19 | |
|
20 | # third party | |
|
21 | import nose.tools as nt | |
|
22 | ||
|
23 | 20 | from IPython.testing.decorators import skip_iptest_but_not_pytest |
|
24 | 21 | |
|
25 | 22 | # our own |
@@ -65,7 +62,7 b' def test_parse_sample(style):' | |||
|
65 | 62 | buf.seek(0) |
|
66 | 63 | f1 = buf.read() |
|
67 | 64 | |
|
68 |
|
|
|
65 | assert "ERROR" not in f1 | |
|
69 | 66 | |
|
70 | 67 | |
|
71 | 68 | @skip_iptest_but_not_pytest |
@@ -73,4 +70,4 b' def test_parse_error(style):' | |||
|
73 | 70 | p = Parser(style=style) |
|
74 | 71 | f1 = p.format(")", "str") |
|
75 | 72 | if style != "NoColor": |
|
76 |
|
|
|
73 | assert "ERROR" in f1 |
@@ -5,7 +5,6 b'' | |||
|
5 | 5 | # Distributed under the terms of the Modified BSD License. |
|
6 | 6 | |
|
7 | 7 | import json |
|
8 | import nose.tools as nt | |
|
9 | 8 | |
|
10 | 9 | from IPython.utils import sysinfo |
|
11 | 10 |
@@ -17,9 +17,10 b' import math' | |||
|
17 | 17 | import random |
|
18 | 18 | import sys |
|
19 | 19 | |
|
20 | import nose.tools as nt | |
|
21 | 20 | from pathlib import Path |
|
22 | 21 | |
|
22 | import pytest | |
|
23 | ||
|
23 | 24 | from IPython.utils import text |
|
24 | 25 | |
|
25 | 26 | #----------------------------------------------------------------------------- |
@@ -116,8 +117,9 b' def eval_formatter_check(f):' | |||
|
116 | 117 | assert s == ns["u"] |
|
117 | 118 | # This decodes in a platform dependent manner, but it shouldn't error out |
|
118 | 119 | s = f.format("{b}", **ns) |
|
119 | ||
|
120 |
|
|
|
120 | ||
|
121 | pytest.raises(NameError, f.format, "{dne}", **ns) | |
|
122 | ||
|
121 | 123 | |
|
122 | 124 | def eval_formatter_slicing_check(f): |
|
123 | 125 | ns = dict(n=12, pi=math.pi, stuff='hello there', os=os) |
@@ -128,7 +130,7 b' def eval_formatter_slicing_check(f):' | |||
|
128 | 130 | s = f.format("{stuff[::2]}", **ns) |
|
129 | 131 | assert s == ns["stuff"][::2] |
|
130 | 132 | |
|
131 |
|
|
|
133 | pytest.raises(SyntaxError, f.format, "{n:x}", **ns) | |
|
132 | 134 | |
|
133 | 135 | def eval_formatter_no_slicing_check(f): |
|
134 | 136 | ns = dict(n=12, pi=math.pi, stuff='hello there', os=os) |
@@ -194,7 +196,7 b' def test_LSString():' | |||
|
194 | 196 | assert lss.l == ["abc", "def"] |
|
195 | 197 | assert lss.s == "abc def" |
|
196 | 198 | lss = text.LSString(os.getcwd()) |
|
197 |
|
|
|
199 | assert isinstance(lss.p[0], Path) | |
|
198 | 200 | |
|
199 | 201 | def test_SList(): |
|
200 | 202 | sl = text.SList(["a 11", "b 1", "a 2"]) |
@@ -2,7 +2,6 b'' | |||
|
2 | 2 | # Copyright (c) IPython Development Team. |
|
3 | 3 | # Distributed under the terms of the Modified BSD License. |
|
4 | 4 | |
|
5 | import nose.tools as nt | |
|
6 | 5 | import pytest |
|
7 | 6 | from IPython.testing.decorators import skip_iptest_but_not_pytest |
|
8 | 7 | |
@@ -17,13 +16,16 b' def expect_token(expected, cell, cursor_pos):' | |||
|
17 | 16 | else: |
|
18 | 17 | offset += len(line)+1 |
|
19 | 18 | column = cursor_pos - offset |
|
20 |
line_with_cursor = |
|
|
21 | nt.assert_equal(token, expected, | |
|
22 | "Expected %r, got %r in: %r (pos %i)" % ( | |
|
23 | expected, token, line_with_cursor, cursor_pos) | |
|
19 | line_with_cursor = "%s|%s" % (line[:column], line[column:]) | |
|
20 | assert token == expected, "Expected %r, got %r in: %r (pos %i)" % ( | |
|
21 | expected, | |
|
22 | token, | |
|
23 | line_with_cursor, | |
|
24 | cursor_pos, | |
|
24 | 25 | ) |
|
25 | 26 | |
|
26 | def test_simple(): | |
|
27 | ||
|
28 | def test_simple(): | |
|
27 | 29 | cell = "foo" |
|
28 | 30 | for i in range(len(cell)): |
|
29 | 31 | expect_token("foo", cell, i) |
@@ -107,20 +109,20 b' def test_attrs():' | |||
|
107 | 109 | def test_line_at_cursor(): |
|
108 | 110 | cell = "" |
|
109 | 111 | (line, offset) = line_at_cursor(cell, cursor_pos=11) |
|
110 |
|
|
|
111 |
|
|
|
112 | assert line == "" | |
|
113 | assert offset == 0 | |
|
112 | 114 | |
|
113 | 115 | # The position after a newline should be the start of the following line. |
|
114 | 116 | cell = "One\nTwo\n" |
|
115 | 117 | (line, offset) = line_at_cursor(cell, cursor_pos=4) |
|
116 |
|
|
|
117 |
|
|
|
118 | assert line == "Two\n" | |
|
119 | assert offset == 4 | |
|
118 | 120 | |
|
119 | 121 | # The end of a cell should be on the last line |
|
120 | 122 | cell = "pri\npri" |
|
121 | 123 | (line, offset) = line_at_cursor(cell, cursor_pos=7) |
|
122 |
|
|
|
123 |
|
|
|
124 | assert line == "pri" | |
|
125 | assert offset == 4 | |
|
124 | 126 | |
|
125 | 127 | |
|
126 | 128 | @pytest.mark.parametrize( |
General Comments 0
You need to be logged in to leave comments.
Login now