gh-79871: IDLE - Fix and test debugger module

Lib/idlelib/debugger.py

@@ -10,12 +10,20 @@
 
 
 class Idb(bdb.Bdb):
+    """Idle debugger, based on the bdb debugger."""
 
     def __init__(self, gui):
         self.gui = gui  # An instance of Debugger or proxy of remote.
-        bdb.Bdb.__init__(self)
+        self.botframe = None
+        super(Idb, self).__init__()
 
     def user_line(self, frame):
+        """
+        Handle a user stopping or breaking at a line.
+
+        Implements Bdb.user_line() to convert frame to string
+        and send message to GUI.
+        """
         if self.in_rpc_code(frame):
             self.set_step()
             return
@@ -25,18 +33,22 @@ def user_line(self, frame):
         except TclError:  # When closing debugger window with [x] in 3.x
             pass
 
-    def user_exception(self, frame, info):
+    def user_exception(self, frame, exc_info):
+        """Handle an the occurrence of an exception."""
         if self.in_rpc_code(frame):
             self.set_step()
             return
         message = self.__frame2message(frame)
-        self.gui.interaction(message, frame, info)
+        self.gui.interaction(message, frame, exc_info)
 
     def in_rpc_code(self, frame):
+        """Determine if debugger is within RPC code."""
         if frame.f_code.co_filename.count('rpc.py'):
             return True
         else:
             prev_frame = frame.f_back
+            if prev_frame is None:
+                return False
             prev_name = prev_frame.f_code.co_filename
             if 'idlelib' in prev_name and 'debugger' in prev_name:
                 # catch both idlelib/debugger.py and idlelib/debugger_r.py
@@ -45,6 +57,7 @@ def in_rpc_code(self, frame):
             return self.in_rpc_code(prev_frame)
 
     def __frame2message(self, frame):
+        """Convert a frame to a message string."""
         code = frame.f_code
         filename = code.co_filename
         lineno = frame.f_lineno
@@ -56,10 +69,30 @@ def __frame2message(self, frame):
 
 
 class Debugger:
-
-    vstack = vsource = vlocals = vglobals = None
+    """
+    The debugger interface.
+
+    This class handles the drawing of the debugger window and
+    the interactions with the underlying debugger session.
+    """
+    vstack = None
+    vsource = None
+    vlocals = None
+    vglobals = None
+    stackviewer = None
+    localsviewer = None
+    globalsviewer = None
 
     def __init__(self, pyshell, idb=None):
+        """
+        Instantiate and draw a debugger window.
+
+        :param pyshell: An instance of the PyShell Window
+        :type  pyshell: :class:`idlelib.pyshell.PyShell`
+
+        :param idb: An instance of the IDLE debugger (optional)
+        :type  idb: :class:`idlelib.debugger.Idb`
+        """
         if idb is None:
             idb = Idb(self)
         self.pyshell = pyshell
@@ -70,6 +103,7 @@ def __init__(self, pyshell, idb=None):
         self.nesting_level = 0
 
     def run(self, *args):
+        """Run the debugger."""
         # Deal with the scenario where we've already got a program running
         # in the debugger and we want to start another. If that is the case,
         # our second 'run' was invoked from an event dispatched not from
@@ -110,6 +144,7 @@ def run(self, *args):
             self.interacting = 0
 
     def close(self, event=None):
+        """Close the debugger and window."""
         try:
             self.quit()
         except Exception:
@@ -127,6 +162,7 @@ def close(self, event=None):
         self.top.destroy()
 
     def make_gui(self):
+        """Draw the debugger gui on the screen."""
         pyshell = self.pyshell
         self.flist = pyshell.flist
         self.root = root = pyshell.root
@@ -287,8 +323,6 @@ def quit(self):
     def abort_loop(self):
         self.root.tk.call('set', '::idledebugwait', '1')
 
-    stackviewer = None
-
     def show_stack(self):
         if not self.stackviewer and self.vstack.get():
             self.stackviewer = sv = StackViewer(self.fstack, self.flist, self)
@@ -310,9 +344,6 @@ def show_frame(self, stackitem):
         self.frame = stackitem[0]  # lineno is stackitem[1]
         self.show_variables()
 
-    localsviewer = None
-    globalsviewer = None
-
     def show_locals(self):
         lv = self.localsviewer
         if self.vlocals.get():
@@ -363,7 +394,7 @@ def clear_file_breaks(self, filename):
         self.idb.clear_all_file_breaks(filename)
 
     def load_breakpoints(self):
-        "Load PyShellEditorWindow breakpoints into subprocess debugger"
+        """Load PyShellEditorWindow breakpoints into subprocess debugger."""
         for editwin in self.pyshell.flist.inversedict:
             filename = editwin.io.filename
             try:
@@ -372,6 +403,7 @@ def load_breakpoints(self):
             except AttributeError:
                 continue
 
+
 class StackViewer(ScrolledList):
 
     def __init__(self, master, flist, gui):
@@ -543,6 +575,7 @@ def load_dict(self, dict, force=0, rpc_client=None):
     def close(self):
         self.frame.destroy()
 
+
 if __name__ == "__main__":
     from unittest import main
     main('idlelib.idle_test.test_debugger', verbosity=2, exit=False)

Lib/idlelib/idle_test/test_debugger.py

@@ -2,9 +2,11 @@
 
 from idlelib import debugger
 import unittest
+from unittest import mock
 from test.support import requires
-requires('gui')
+# requires('gui')
 from tkinter import Tk
+from textwrap import dedent
 
 
 class NameSpaceTest(unittest.TestCase):
@@ -23,7 +25,218 @@ def test_init(self):
         debugger.NamespaceViewer(self.root, 'Test')
 
 
-# Other classes are Idb, Debugger, and StackViewer.
+class MockFrameType(object):
+    """Reflection of the types.FrameType."""
+    f_back = None
+    f_builtins = None
+    f_code = None
+    f_globals = None
+    f_lasti = None
+    f_lineno = None
+    f_locals = None
+    f_restricted = 0
+    f_trace = None
+
+    def __init__(self):
+        pass
+
+
+class IdbTest(unittest.TestCase):
+
+    def test_init_runs_bdb_init(self):
+        """Test that Idb calls the base Bdb __init__."""
+        idb = debugger.Idb(None)
+        assert idb.gui is None
+        assert hasattr(idb, 'breaks')
+
+    def test_user_line_basic_frame(self):
+        """Test that .user_line() creates a string message for a frame."""
+
+        # Create a test code object to simulate a debug session.
+        test_code = dedent("""
+        i = 1
+        i += 2
+        if i == 3:
+           print(i)
+        """)
+        code_obj = compile(test_code,
+                           'test_user_line_basic_frame.py',
+                           mode='exec')
+
+        # Create 2 test frames for lines 1 and 2 of the test code.
+        test_frame1 = MockFrameType()
+        test_frame1.f_code = code_obj
+        test_frame1.f_lineno = 1
+
+        test_frame2 = MockFrameType()
+        test_frame2.f_code = code_obj
+        test_frame2.f_lineno = 2
+        test_frame2.f_back = test_frame1
+
+        gui = mock.Mock()
+        gui.interaction = mock.Mock()
+
+        idb = debugger.Idb(gui)
+        idb.user_line(test_frame2)
+
+        assert not idb.in_rpc_code(test_frame2)
+        gui.interaction.assert_called_once()
+        gui.interaction.assert_called_with('test_user_line_basic_frame.py:2: <module>()', test_frame2)
+
+    def test_user_exception(self):
+        """Test that .user_exception() creates a string message for a frame."""
+
+        # Create a test code object to simulate a debug session.
+        test_code = dedent("""
+        i = 1
+        i += 2
+        if i == 3:
+           print(i)
+        """)
+        code_obj = compile(test_code,
+                           'test_user_exception.py',
+                           mode='exec')
+
+        # Create 1 test frame
+        test_frame1 = MockFrameType()
+        test_frame1.f_code = code_obj
+        test_frame1.f_lineno = 1
+
+        # Example from sys.exc_info()
+        test_exc_info = (type(ValueError), ValueError(), None)
+
+        gui = mock.Mock()
+        gui.interaction = mock.Mock()
+
+        idb = debugger.Idb(gui)
+        idb.user_exception(test_frame1, test_exc_info)
+
+        assert not idb.in_rpc_code(test_frame1)
+        gui.interaction.assert_called_once()
+        gui.interaction.assert_called_with('test_user_exception.py:1: <module>()', test_frame1, test_exc_info)
+
+    def test_in_rpc_code_rpc_py(self):
+        """Test that .in_rpc_code detects position of rpc.py."""
+
+        # Create a test code object to simulate a debug session.
+        test_code = dedent("""
+            i = 1
+            i += 2
+            if i == 3:
+               print(i)
+            """)
+        code_obj = compile(test_code,
+                           'rpc.py',
+                           mode='exec')
+
+        # Create 1 test frame
+        test_frame = MockFrameType()
+        test_frame.f_code = code_obj
+        test_frame.f_lineno = 1
+
+        gui = mock.Mock()
+        gui.interaction = mock.Mock()
+
+        idb = debugger.Idb(gui)
+
+        assert idb.in_rpc_code(test_frame)
+
+    def test_in_rpc_code_debugger_star_dot_py(self):
+        """Test that .in_rpc_code detects position of idlelib/debugger*.py."""
+
+        # Create a test code object to simulate a debug session.
+        for filename in ('idlelib/debugger.py', 'idlelib/debugger_r.py'):
+            test_code = dedent("""
+                    i = 1
+                    i += 2
+                    if i == 3:
+                       print(i)
+                    """)
+            code_obj = compile(test_code,
+                               filename,
+                               mode='exec')
+
+            # Create 2 test frames
+            test_frame = MockFrameType()
+            test_frame.f_code = code_obj
+            test_frame.f_lineno = 1
+
+            test_frame2 = MockFrameType()
+            test_frame2.f_code = code_obj
+            test_frame2.f_lineno = 2
+            test_frame2.f_back = test_frame
+
+            gui = mock.Mock()
+            gui.interaction = mock.Mock()
+
+            idb = debugger.Idb(gui)
+
+            assert not idb.in_rpc_code(test_frame2)
+
+
+def make_pyshell_mock():
+    """Factory for generating test fixtures of PyShell."""
+    pyshell = mock.Mock()
+    pyshell.root = None
+    return pyshell
+
+
+class DebuggerTest(unittest.TestCase):
+    """Tests for the idlelib.debugger.Debugger class."""
+
+    def test_setup_debugger(self):
+        """Test that Debugger can be instantiated with a mock PyShell."""
+        pyshell = make_pyshell_mock()
+        test_debugger = debugger.Debugger(pyshell)
+
+        assert test_debugger.pyshell == pyshell
+        assert test_debugger.frame is None
+
+    def test_run_debugger_with_idb(self):
+        """Test Debugger.run() with an Idb instance."""
+        mock_idb = mock.Mock()  # Mocked debugger.Idb
+        test_debugger = debugger.Debugger(make_pyshell_mock(), idb=mock_idb)
+        test_debugger.run(1, 'two')
+        mock_idb.run.assert_called_once()
+        mock_idb.run.called_with(1, 'two')
+        assert test_debugger.interacting == 0
+
+    def test_run_debugger_no_idb(self):
+        """Test Debugger.run() with no Idb instance."""
+        test_debugger = debugger.Debugger(make_pyshell_mock(), idb=None)
+        assert test_debugger.idb is not None
+        test_debugger.idb.run = mock.Mock()
+        test_debugger.run(1, 'two')
+        test_debugger.idb.run.assert_called_once()
+        test_debugger.idb.run.called_with(1, 'two')
+        assert test_debugger.interacting == 0
+
+    def test_close(self):
+        """Test closing the window in an idle state."""
+        pyshell = make_pyshell_mock()
+        test_debugger = debugger.Debugger(pyshell)
+        test_debugger.close()
+        pyshell.close_debugger.assert_called_once()
+
+    def test_close_whilst_interacting(self):
+        """Test closing the window in an interactive state."""
+        pyshell = make_pyshell_mock()
+        test_debugger = debugger.Debugger(pyshell)
+        test_debugger.interacting = 1
+        test_debugger.close()
+        pyshell.close_debugger.assert_not_called()
+
+    def test_interaction_with_message_and_frame(self):
+        test_message = "testing 1234.."
+        test_frame = MockFrameType()
+
+        pyshell = make_pyshell_mock()
+        test_debugger = debugger.Debugger(pyshell)
+
+        # Patch out the status label so we can check messages
+        test_debugger.status = mock.Mock()
+        test_debugger.interaction(test_message, test_frame)
+
 
 if __name__ == '__main__':
     unittest.main(verbosity=2)