| """Test debugger, coverage 66% |
| |
| Try to make tests pass with draft bdbx, which may replace bdb in 3.13+. |
| """ |
| |
| from idlelib import debugger |
| from collections import namedtuple |
| from textwrap import dedent |
| from tkinter import Tk |
| |
| from test.support import requires |
| import unittest |
| from unittest import mock |
| from unittest.mock import Mock, patch |
| |
| """A test python script for the debug tests.""" |
| TEST_CODE = dedent(""" |
| i = 1 |
| i += 2 |
| if i == 3: |
| print(i) |
| """) |
| |
| |
| class MockFrame: |
| "Minimal mock frame." |
| |
| def __init__(self, code, lineno): |
| self.f_code = code |
| self.f_lineno = lineno |
| |
| |
| class IdbTest(unittest.TestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| cls.gui = Mock() |
| cls.idb = debugger.Idb(cls.gui) |
| |
| # Create test and code objects to simulate a debug session. |
| code_obj = compile(TEST_CODE, 'idlelib/file.py', mode='exec') |
| frame1 = MockFrame(code_obj, 1) |
| frame1.f_back = None |
| frame2 = MockFrame(code_obj, 2) |
| frame2.f_back = frame1 |
| cls.frame = frame2 |
| cls.msg = 'file.py:2: <module>()' |
| |
| def test_init(self): |
| self.assertIs(self.idb.gui, self.gui) |
| # Won't test super call since two Bdbs are very different. |
| |
| def test_user_line(self): |
| # Test that .user_line() creates a string message for a frame. |
| self.gui.interaction = Mock() |
| self.idb.user_line(self.frame) |
| self.gui.interaction.assert_called_once_with(self.msg, self.frame) |
| |
| def test_user_exception(self): |
| # Test that .user_exception() creates a string message for a frame. |
| exc_info = (type(ValueError), ValueError(), None) |
| self.gui.interaction = Mock() |
| self.idb.user_exception(self.frame, exc_info) |
| self.gui.interaction.assert_called_once_with( |
| self.msg, self.frame, exc_info) |
| |
| |
| class FunctionTest(unittest.TestCase): |
| # Test module functions together. |
| |
| def test_functions(self): |
| rpc_obj = compile(TEST_CODE,'rpc.py', mode='exec') |
| rpc_frame = MockFrame(rpc_obj, 2) |
| rpc_frame.f_back = rpc_frame |
| self.assertTrue(debugger._in_rpc_code(rpc_frame)) |
| self.assertEqual(debugger._frame2message(rpc_frame), |
| 'rpc.py:2: <module>()') |
| |
| code_obj = compile(TEST_CODE, 'idlelib/debugger.py', mode='exec') |
| code_frame = MockFrame(code_obj, 1) |
| code_frame.f_back = None |
| self.assertFalse(debugger._in_rpc_code(code_frame)) |
| self.assertEqual(debugger._frame2message(code_frame), |
| 'debugger.py:1: <module>()') |
| |
| code_frame.f_back = code_frame |
| self.assertFalse(debugger._in_rpc_code(code_frame)) |
| code_frame.f_back = rpc_frame |
| self.assertTrue(debugger._in_rpc_code(code_frame)) |
| |
| |
| class DebuggerTest(unittest.TestCase): |
| "Tests for Debugger that do not need a real root." |
| |
| @classmethod |
| def setUpClass(cls): |
| cls.pyshell = Mock() |
| cls.pyshell.root = Mock() |
| cls.idb = Mock() |
| with patch.object(debugger.Debugger, 'make_gui'): |
| cls.debugger = debugger.Debugger(cls.pyshell, cls.idb) |
| cls.debugger.root = Mock() |
| |
| def test_cont(self): |
| self.debugger.cont() |
| self.idb.set_continue.assert_called_once() |
| |
| def test_step(self): |
| self.debugger.step() |
| self.idb.set_step.assert_called_once() |
| |
| def test_quit(self): |
| self.debugger.quit() |
| self.idb.set_quit.assert_called_once() |
| |
| def test_next(self): |
| with patch.object(self.debugger, 'frame') as frame: |
| self.debugger.next() |
| self.idb.set_next.assert_called_once_with(frame) |
| |
| def test_ret(self): |
| with patch.object(self.debugger, 'frame') as frame: |
| self.debugger.ret() |
| self.idb.set_return.assert_called_once_with(frame) |
| |
| def test_clear_breakpoint(self): |
| self.debugger.clear_breakpoint('test.py', 4) |
| self.idb.clear_break.assert_called_once_with('test.py', 4) |
| |
| def test_clear_file_breaks(self): |
| self.debugger.clear_file_breaks('test.py') |
| self.idb.clear_all_file_breaks.assert_called_once_with('test.py') |
| |
| def test_set_load_breakpoints(self): |
| # Test the .load_breakpoints() method calls idb. |
| FileIO = namedtuple('FileIO', 'filename') |
| |
| class MockEditWindow(object): |
| def __init__(self, fn, breakpoints): |
| self.io = FileIO(fn) |
| self.breakpoints = breakpoints |
| |
| self.pyshell.flist = Mock() |
| self.pyshell.flist.inversedict = ( |
| MockEditWindow('test1.py', [4, 4]), |
| MockEditWindow('test2.py', [13, 44, 45]), |
| ) |
| self.debugger.set_breakpoint('test0.py', 1) |
| self.idb.set_break.assert_called_once_with('test0.py', 1) |
| self.debugger.load_breakpoints() # Call set_breakpoint 5 times. |
| self.idb.set_break.assert_has_calls( |
| [mock.call('test0.py', 1), |
| mock.call('test1.py', 4), |
| mock.call('test1.py', 4), |
| mock.call('test2.py', 13), |
| mock.call('test2.py', 44), |
| mock.call('test2.py', 45)]) |
| |
| def test_sync_source_line(self): |
| # Test that .sync_source_line() will set the flist.gotofileline with fixed frame. |
| test_code = compile(TEST_CODE, 'test_sync.py', 'exec') |
| test_frame = MockFrame(test_code, 1) |
| self.debugger.frame = test_frame |
| |
| self.debugger.flist = Mock() |
| with patch('idlelib.debugger.os.path.exists', return_value=True): |
| self.debugger.sync_source_line() |
| self.debugger.flist.gotofileline.assert_called_once_with('test_sync.py', 1) |
| |
| |
| class DebuggerGuiTest(unittest.TestCase): |
| """Tests for debugger.Debugger that need tk root. |
| |
| close needs debugger.top set in make_gui. |
| """ |
| |
| @classmethod |
| def setUpClass(cls): |
| requires('gui') |
| cls.root = root = Tk() |
| root.withdraw() |
| cls.pyshell = Mock() |
| cls.pyshell.root = root |
| cls.idb = Mock() |
| # stack tests fail with debugger here. |
| ## cls.debugger = debugger.Debugger(cls.pyshell, cls.idb) |
| ## cls.debugger.root = root |
| ## # real root needed for real make_gui |
| ## # run, interacting, abort_loop |
| |
| @classmethod |
| def tearDownClass(cls): |
| cls.root.destroy() |
| del cls.root |
| |
| def setUp(self): |
| self.debugger = debugger.Debugger(self.pyshell, self.idb) |
| self.debugger.root = self.root |
| # real root needed for real make_gui |
| # run, interacting, abort_loop |
| |
| def test_run_debugger(self): |
| self.debugger.run(1, 'two') |
| self.idb.run.assert_called_once_with(1, 'two') |
| self.assertEqual(self.debugger.interacting, 0) |
| |
| def test_close(self): |
| # Test closing the window in an idle state. |
| self.debugger.close() |
| self.pyshell.close_debugger.assert_called_once() |
| |
| def test_show_stack(self): |
| self.debugger.show_stack() |
| self.assertEqual(self.debugger.stackviewer.gui, self.debugger) |
| |
| def test_show_stack_with_frame(self): |
| test_frame = MockFrame(None, None) |
| self.debugger.frame = test_frame |
| |
| # Reset the stackviewer to force it to be recreated. |
| self.debugger.stackviewer = None |
| self.idb.get_stack.return_value = ([], 0) |
| self.debugger.show_stack() |
| |
| # Check that the newly created stackviewer has the test gui as a field. |
| self.assertEqual(self.debugger.stackviewer.gui, self.debugger) |
| self.idb.get_stack.assert_called_once_with(test_frame, None) |
| |
| |
| class StackViewerTest(unittest.TestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| requires('gui') |
| cls.root = Tk() |
| cls.root.withdraw() |
| |
| @classmethod |
| def tearDownClass(cls): |
| cls.root.destroy() |
| del cls.root |
| |
| def setUp(self): |
| self.code = compile(TEST_CODE, 'test_stackviewer.py', 'exec') |
| self.stack = [ |
| (MockFrame(self.code, 1), 1), |
| (MockFrame(self.code, 2), 2) |
| ] |
| # Create a stackviewer and load the test stack. |
| self.sv = debugger.StackViewer(self.root, None, None) |
| self.sv.load_stack(self.stack) |
| |
| def test_init(self): |
| # Test creation of StackViewer. |
| gui = None |
| flist = None |
| master_window = self.root |
| sv = debugger.StackViewer(master_window, flist, gui) |
| self.assertTrue(hasattr(sv, 'stack')) |
| |
| def test_load_stack(self): |
| # Test the .load_stack() method against a fixed test stack. |
| # Check the test stack is assigned and the list contains the repr of them. |
| self.assertEqual(self.sv.stack, self.stack) |
| self.assertTrue('?.<module>(), line 1:' in self.sv.get(0)) |
| self.assertEqual(self.sv.get(1), '?.<module>(), line 2: ') |
| |
| def test_show_source(self): |
| # Test the .show_source() method against a fixed test stack. |
| # Patch out the file list to monitor it |
| self.sv.flist = Mock() |
| # Patch out isfile to pretend file exists. |
| with patch('idlelib.debugger.os.path.isfile', return_value=True) as isfile: |
| self.sv.show_source(1) |
| isfile.assert_called_once_with('test_stackviewer.py') |
| self.sv.flist.open.assert_called_once_with('test_stackviewer.py') |
| |
| |
| class NameSpaceTest(unittest.TestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| requires('gui') |
| cls.root = Tk() |
| cls.root.withdraw() |
| |
| @classmethod |
| def tearDownClass(cls): |
| cls.root.destroy() |
| del cls.root |
| |
| def test_init(self): |
| debugger.NamespaceViewer(self.root, 'Test') |
| |
| |
| if __name__ == '__main__': |
| unittest.main(verbosity=2) |
