def test_extension_loading(): em = get_ipython().extension_manager with TemporaryDirectory() as td: ext1 = os.path.join(td, 'ext1.py') with open(ext1, 'w') as f: f.write(ext1_content) ext2 = os.path.join(td, 'ext2.py') with open(ext2, 'w') as f: f.write(ext2_content) with prepended_to_syspath(td): assert 'ext1' not in em.loaded assert 'ext2' not in em.loaded # Load extension with tt.AssertPrints("Running ext1 load"): assert em.load_extension('ext1') is None assert 'ext1' in em.loaded # Should refuse to load it again with tt.AssertNotPrints("Running ext1 load"): assert em.load_extension('ext1') == 'already loaded' # Reload with tt.AssertPrints("Running ext1 unload"): with tt.AssertPrints("Running ext1 load", suppress=False): em.reload_extension('ext1') # Unload with tt.AssertPrints("Running ext1 unload"): assert em.unload_extension('ext1') is None # Can't unload again with tt.AssertNotPrints("Running ext1 unload"): assert em.unload_extension('ext1') == 'not loaded' assert em.unload_extension('ext2') == 'not loaded' # Load extension 2 with tt.AssertPrints("Running ext2 load"): assert em.load_extension('ext2') is None # Can't unload this assert em.unload_extension('ext2') == 'no unload function' # But can reload it with tt.AssertPrints("Running ext2 load"): em.reload_extension('ext2')
def test_time3(): """Erroneous magic function calls, issue gh-3334""" ip = get_ipython() ip.user_ns.pop('run', None) with tt.AssertNotPrints("not found", channel='stderr'): ip.run_cell("%%time\n" "run = 0\n" "run += 1")
def test_changing_py_file(self): """Traceback produced if the line where the error occurred is missing? https://github.com/ipython/ipython/issues/1456 """ with TemporaryDirectory() as td: fname = os.path.join(td, "foo.py") with open(fname, "w") as f: f.write(file_1) with prepended_to_syspath(td): ip.run_cell("import foo") with tt.AssertPrints("ZeroDivisionError"): ip.run_cell("foo.f()") # Make the file shorter, so the line of the error is missing. with open(fname, "w") as f: f.write(file_2) # For some reason, this was failing on the *second* call after # changing the file, so we call f() twice. with tt.AssertNotPrints("Internal Python error", channel='stderr'): with tt.AssertPrints("ZeroDivisionError"): ip.run_cell("foo.f()") with tt.AssertPrints("ZeroDivisionError"): ip.run_cell("foo.f()")
def test_run_cell(self): with tt.AssertPrints('-34'): ip.run_cell('print (12 + 22)') # A named reference to a number shouldn't be transformed. ip.user_ns['n'] = 55 with tt.AssertNotPrints('-55'): ip.run_cell('print (n)')
def test_no_dep(self): """ No deprecation warning should be raised from imported functions """ ip.run_cell("from {} import wrn".format(self.fname)) with tt.AssertNotPrints("I AM A WARNING"): ip.run_cell("wrn()") ip.run_cell("del wrn")
def test_ignore_sys_exit(self): """Test the -e option to ignore sys.exit()""" src = "import sys; sys.exit(1)" self.mktmp(src) with tt.AssertPrints('SystemExit'): _ip.magic('run %s' % self.fname) with tt.AssertNotPrints('SystemExit'): _ip.magic('run -e %s' % self.fname)
def test_logging_magic_quiet_from_config(): _ip.config.LoggingMagics.quiet = True lm = logging.LoggingMagics(shell=_ip) with TemporaryDirectory() as td: try: with tt.AssertNotPrints(re.compile("Activating.*")): lm.logstart(os.path.join(td, "quiet_from_config.log")) finally: _ip.logger.logstop()
def test_run_debug_twice_with_breakpoint(self): """Make a valid python temp file.""" _ip = get_ipython() with tt.fake_input(['b 2', 'c', 'c']): _ip.magic('run -d %s' % self.fname) with tt.fake_input(['c']): with tt.AssertNotPrints('KeyError'): _ip.magic('run -d %s' % self.fname)
def test_syntaxerror_no_stacktrace_at_compile_time(self): syntax_error_at_compile_time = """ def foo(): .. """ with tt.AssertPrints("SyntaxError"): ip.run_cell(syntax_error_at_compile_time) with tt.AssertNotPrints("foo()"): ip.run_cell(syntax_error_at_compile_time)
def testLogging(self): message = "An unexpected error occurred while tokenizing input" cell = 'raise ValueError("""a\nb""")' stream = io.StringIO() handler = logging.StreamHandler(stream) logger = logging.getLogger() loglevel = logger.level logger.addHandler(handler) self.addCleanup(lambda: logger.removeHandler(handler)) self.addCleanup(lambda: logger.setLevel(loglevel)) logger.setLevel(logging.INFO) with tt.AssertNotPrints(message): ip.run_cell(cell) self.assertNotIn(message, stream.getvalue()) logger.setLevel(logging.DEBUG) with tt.AssertNotPrints(message): ip.run_cell(cell) self.assertIn(message, stream.getvalue())
def test_input_rejection(self): """Check that NodeTransformers can reject input.""" expect_exception_tb = tt.AssertPrints("InputRejected: test") expect_no_cell_output = tt.AssertNotPrints("'unsafe'", suppress=False) # Run the same check twice to verify that the transformer is not # disabled after raising. with expect_exception_tb, expect_no_cell_output: ip.run_cell("'unsafe'") with expect_exception_tb, expect_no_cell_output: res = ip.run_cell("'unsafe'") self.assertIsInstance(res.error_before_exec, InputRejected)
def test_reload_enums(self): import enum mod_name, mod_fn = self.new_module( textwrap.dedent(""" from enum import Enum class MyEnum(Enum): A = 'A' B = 'B' """)) self.shell.magic_autoreload("2") self.shell.magic_aimport(mod_name) self.write_file( mod_fn, textwrap.dedent(""" from enum import Enum class MyEnum(Enum): A = 'A' B = 'B' C = 'C' """)) with tt.AssertNotPrints(('[autoreload of %s failed:' % mod_name), channel='stderr'): self.shell.run_code("pass") # trigger another reload
def test_suppress_exception_chaining(self): with tt.AssertNotPrints("ZeroDivisionError"), \ tt.AssertPrints("ValueError", suppress=False): ip.run_cell(self.SUPPRESS_CHAINING_CODE)
def _check_smoketest(self, use_aimport=True): """ Functional test for the automatic reloader using either '%autoreload 1' or '%autoreload 2' """ mod_name, mod_fn = self.new_module(""" x = 9 z = 123 # this item will be deleted def foo(y): return y + 3 class Baz(object): def __init__(self, x): self.x = x def bar(self, y): return self.x + y @property def quux(self): return 42 def zzz(self): '''This method will be deleted below''' return 99 class Bar: # old-style class: weakref doesn't work for it on Python < 2.7 def foo(self): return 1 """) # # Import module, and mark for reloading # if use_aimport: self.shell.magic_autoreload("1") self.shell.magic_aimport(mod_name) stream = StringIO() self.shell.magic_aimport("", stream=stream) nt.assert_in(("Modules to reload:\n%s" % mod_name), stream.getvalue()) with nt.assert_raises(ImportError): self.shell.magic_aimport("tmpmod_as318989e89ds") else: self.shell.magic_autoreload("2") self.shell.run_code("import %s" % mod_name) stream = StringIO() self.shell.magic_aimport("", stream=stream) nt.assert_true( "Modules to reload:\nall-except-skipped" in stream.getvalue()) nt.assert_in(mod_name, self.shell.ns) mod = sys.modules[mod_name] # # Test module contents # old_foo = mod.foo old_obj = mod.Baz(9) old_obj2 = mod.Bar() def check_module_contents(): nt.assert_equal(mod.x, 9) nt.assert_equal(mod.z, 123) nt.assert_equal(old_foo(0), 3) nt.assert_equal(mod.foo(0), 3) obj = mod.Baz(9) nt.assert_equal(old_obj.bar(1), 10) nt.assert_equal(obj.bar(1), 10) nt.assert_equal(obj.quux, 42) nt.assert_equal(obj.zzz(), 99) obj2 = mod.Bar() nt.assert_equal(old_obj2.foo(), 1) nt.assert_equal(obj2.foo(), 1) check_module_contents() # # Simulate a failed reload: no reload should occur and exactly # one error message should be printed # self.write_file(mod_fn, """ a syntax error """) with tt.AssertPrints(('[autoreload of %s failed:' % mod_name), channel='stderr'): self.shell.run_code("pass") # trigger reload with tt.AssertNotPrints(('[autoreload of %s failed:' % mod_name), channel='stderr'): self.shell.run_code("pass") # trigger another reload check_module_contents() # # Rewrite module (this time reload should succeed) # self.write_file( mod_fn, """ x = 10 def foo(y): return y + 4 class Baz(object): def __init__(self, x): self.x = x def bar(self, y): return self.x + y + 1 @property def quux(self): return 43 class Bar: # old-style class def foo(self): return 2 """) def check_module_contents(): nt.assert_equal(mod.x, 10) nt.assert_false(hasattr(mod, 'z')) nt.assert_equal(old_foo(0), 4) # superreload magic! nt.assert_equal(mod.foo(0), 4) obj = mod.Baz(9) nt.assert_equal(old_obj.bar(1), 11) # superreload magic! nt.assert_equal(obj.bar(1), 11) nt.assert_equal(old_obj.quux, 43) nt.assert_equal(obj.quux, 43) nt.assert_false(hasattr(old_obj, 'zzz')) nt.assert_false(hasattr(obj, 'zzz')) obj2 = mod.Bar() nt.assert_equal(old_obj2.foo(), 2) nt.assert_equal(obj2.foo(), 2) self.shell.run_code("pass") # trigger reload check_module_contents() # # Another failure case: deleted file (shouldn't reload) # os.unlink(mod_fn) self.shell.run_code("pass") # trigger reload check_module_contents() # # Disable autoreload and rewrite module: no reload should occur # if use_aimport: self.shell.magic_aimport("-" + mod_name) stream = StringIO() self.shell.magic_aimport("", stream=stream) nt.assert_true(("Modules to skip:\n%s" % mod_name) in stream.getvalue()) # This should succeed, although no such module exists self.shell.magic_aimport("-tmpmod_as318989e89ds") else: self.shell.magic_autoreload("0") self.write_file(mod_fn, """ x = -99 """) self.shell.run_code("pass") # trigger reload self.shell.run_code("pass") check_module_contents() # # Re-enable autoreload: reload should now occur # if use_aimport: self.shell.magic_aimport(mod_name) else: self.shell.magic_autoreload("") self.shell.run_code("pass") # trigger reload nt.assert_equal(mod.x, -99)
def test_timeit_quiet(): """ test quiet option of timeit magic """ with tt.AssertNotPrints("loops"): _ip.run_cell("%timeit -n1 -r1 -q 1")
def test_timeit_return_quiet(): with tt.AssertNotPrints("loops"): res = _ip.run_line_magic('timeit', '-n1 -r1 -q -o 1') assert (res is not None)
def test_no_recursion(self): with tt.AssertNotPrints("frames repeated"): ip.run_cell("non_recurs()")
def test_syntaxerror_without_lineno(self): with tt.AssertNotPrints("TypeError"): with tt.AssertPrints("line unknown"): ip.run_cell("raise SyntaxError()")