[pitivi] Get rid of sendFakeEvent methods

[Alexandru Băluț <alexbalut src gnome org>]

commit 1d7ae6687a1bf1ab4f137bba0d5a0110523918fd
Author: Alexandru Băluț <alexandru balut gmail com>
Date:   Thu Oct 6 20:13:29 2016 +0200

    Get rid of sendFakeEvent methods
    
    Use instead mocks, to avoid having testing code in the app.
    
    Reviewed-by: Thibault Saunier <tsaunier gnome org>
    Differential Revision: https://phabricator.freedesktop.org/D1375

 pitivi/timeline/elements.py     |   10 +----
 pitivi/timeline/timeline.py     |   47 ++++-----------------
 pitivi/utils/validate.py        |   86 ++++++++++++++++++++-------------------
 tests/common.py                 |   19 ++++-----
 tests/test_timeline_timeline.py |   37 +++++++++--------
 tests/test_undo_timeline.py     |   32 ++++++++------
 6 files changed, 101 insertions(+), 130 deletions(-)
---
diff --git a/pitivi/timeline/elements.py b/pitivi/timeline/elements.py
index dd6ddc7..766106d 100644
--- a/pitivi/timeline/elements.py
+++ b/pitivi/timeline/elements.py
@@ -887,7 +887,7 @@ class Clip(Gtk.EventBox, Zoomable, Loggable):
             self.__connectToChild(child)
 
         # Connect to Widget signals.
-        self.connect("button-release-event", self.__buttonReleaseEventCb)
+        self.connect("button-release-event", self._button_release_event_cb)
         self.connect("event", self._eventCb)
 
         # Connect to GES signals.
@@ -1005,17 +1005,11 @@ class Clip(Gtk.EventBox, Zoomable, Loggable):
         for handle in self.handles:
             handle.shrink()
 
-    def sendFakeEvent(self, event, event_widget):
-        if event.type == Gdk.EventType.BUTTON_RELEASE:
-            self.__buttonReleaseEventCb(event_widget, event)
-
-        self.timeline.sendFakeEvent(event, event_widget)
-
     def do_draw(self, cr):
         self.updatePosition()
         Gtk.EventBox.do_draw(self, cr)
 
-    def __buttonReleaseEventCb(self, unused_widget, event):
+    def _button_release_event_cb(self, unused_widget, event):
         if self.timeline.got_dragged:
             # This means a drag & drop operation just finished and
             # this button-release-event should be ignored.
diff --git a/pitivi/timeline/timeline.py b/pitivi/timeline/timeline.py
index e69cad9..e2ecbcf 100644
--- a/pitivi/timeline/timeline.py
+++ b/pitivi/timeline/timeline.py
@@ -128,15 +128,16 @@ class Marquee(Gtk.Box, Loggable):
         self.set_visible(False)
 
     def setStartPosition(self, event):
-        event_widget = self._timeline.get_event_widget(event)
+        event_widget = Gtk.get_event_widget(event)
         x, y = event_widget.translate_coordinates(self._timeline, event.x, event.y)
 
         self.start_x, self.start_y = self._timeline.adjustCoords(x=x, y=y)
 
     def move(self, event):
-        event_widget = self._timeline.get_event_widget(event)
+        event_widget = Gtk.get_event_widget(event)
 
-        x, y = self._timeline.adjustCoords(coords=event_widget.translate_coordinates(self._timeline, 
event.x, event.y))
+        coords = event_widget.translate_coordinates(self._timeline, event.x, event.y)
+        x, y = self._timeline.adjustCoords(coords=coords)
 
         start_x = min(x, self.start_x)
         start_y = min(y, self.start_y)
@@ -245,7 +246,6 @@ class Timeline(Gtk.EventBox, Zoomable, Loggable):
         self.get_style_context().add_class("Timeline")
         self.props.expand = True
         self.get_accessible().set_name("timeline canvas")
-        self.__fake_event_widget = None
 
         # A lot of operations go through these callbacks.
         self.add_events(Gdk.EventType.BUTTON_PRESS | Gdk.EventType.BUTTON_RELEASE)
@@ -314,28 +314,6 @@ class Timeline(Gtk.EventBox, Zoomable, Loggable):
     def controls_width(self):
         return self.__layers_controls_vbox.get_allocated_width()
 
-    def sendFakeEvent(self, event, event_widget=None):
-        # Member usefull for testsing
-        self.__fake_event_widget = event_widget
-
-        self.info("Faking %s", event)
-        if event.type == Gdk.EventType.BUTTON_PRESS:
-            self._button_press_event_cb(self, event)
-        elif event.type == Gdk.EventType.BUTTON_RELEASE:
-            self._button_release_event_cb(self, event)
-        elif event.type == Gdk.EventType.MOTION_NOTIFY:
-            self._motion_notify_event_cb(self, event)
-        else:
-            self.parent.sendFakeEvent(event)
-
-        self.__fake_event_widget = None
-
-    def get_event_widget(self, event):
-        if self.__fake_event_widget:
-            return self.__fake_event_widget
-
-        return Gtk.get_event_widget(event)
-
     def resetSelectionGroup(self):
         self.debug("Reset selection group")
         if self.current_group:
@@ -567,7 +545,7 @@ class Timeline(Gtk.EventBox, Zoomable, Loggable):
                 self.error("Could not handle %s scroll event", direction)
                 return False
 
-        event_widget = self.get_event_widget(event)
+        event_widget = Gtk.get_event_widget(event)
         x, y = event_widget.translate_coordinates(self, event.x, event.y)
         if event.get_state() & Gdk.ModifierType.SHIFT_MASK:
             if delta_y > 0:
@@ -628,7 +606,7 @@ class Timeline(Gtk.EventBox, Zoomable, Loggable):
         self.debug("PRESSED %s", event)
         self.app.gui.focusTimeline()
 
-        event_widget = self.get_event_widget(event)
+        event_widget = Gtk.get_event_widget(event)
 
         res, button = event.get_button()
         if res and button == 1:
@@ -702,10 +680,10 @@ class Timeline(Gtk.EventBox, Zoomable, Loggable):
                 return False
 
             if self.got_dragged or self.__drag_start_x != event.x:
-                self.__dragUpdate(self.get_event_widget(event), event.x, event.y)
+                self.__dragUpdate(Gtk.get_event_widget(event), event.x, event.y)
                 self.got_dragged = True
         elif self.__moving_layer:
-            event_widget = self.get_event_widget(event)
+            event_widget = Gtk.get_event_widget(event)
             unused_x, y = event_widget.translate_coordinates(self, event.x, event.y)
             layer, unused_on_sep = self._get_layer_at(
                 y, prefer_ges_layer=self.__moving_layer,
@@ -723,7 +701,7 @@ class Timeline(Gtk.EventBox, Zoomable, Loggable):
         return False
 
     def _seek(self, event):
-        event_widget = self.get_event_widget(event)
+        event_widget = Gtk.get_event_widget(event)
         x, unused_y = event_widget.translate_coordinates(self, event.x, event.y)
         x -= self.controls_width
         x += self.hadj.get_value()
@@ -1724,13 +1702,6 @@ class TimelineContainer(Gtk.Grid, Zoomable, Loggable):
 
     # Gtk widget virtual methods
 
-    def sendFakeEvent(self, event):
-        self.info("Faking %s", event)
-        if event.type == Gdk.EventType.KEY_PRESS:
-            self.do_key_press_event(event)
-        elif event.type == Gdk.EventType.KEY_RELEASE:
-            self.do_key_release_event(event)
-
     def do_key_press_event(self, event):
         # This is used both for changing the selection modes and for affecting
         # the seek keyboard shortcuts further below
diff --git a/pitivi/utils/validate.py b/pitivi/utils/validate.py
index e54be74..a6b1cee 100644
--- a/pitivi/utils/validate.py
+++ b/pitivi/utils/validate.py
@@ -18,6 +18,7 @@
 # Boston, MA 02110-1301, USA.
 import locale
 import subprocess
+from unittest import mock
 
 import gi
 from gi.repository import Gdk
@@ -26,9 +27,7 @@ from gi.repository import GLib
 from gi.repository import Gst
 from gi.repository import Gtk
 
-from pitivi.utils import timeline as timelineUtils
-from pitivi.utils import ui
-
+from pitivi.utils.timeline import Zoomable
 
 CAT = "validate"
 
@@ -47,16 +46,16 @@ has_validate = False
 
 def Event(event_type, **kwargs):
     event_types_constructors = {
-        Gdk.EventType.BUTTON_PRESS: Gdk.EventButton.new,
-        Gdk.EventType.BUTTON_RELEASE: Gdk.EventButton.new,
-        Gdk.EventType.MOTION_NOTIFY: Gdk.EventMotion.new
+        Gdk.EventType.BUTTON_PRESS: Gdk.EventButton,
+        Gdk.EventType.BUTTON_RELEASE: Gdk.EventButton,
+        Gdk.EventType.KEY_PRESS: Gdk.EventKey,
+        Gdk.EventType.KEY_RELEASE: Gdk.EventKey,
+        Gdk.EventType.MOTION_NOTIFY: Gdk.EventMotion
     }
 
-    try:
-        event = event_types_constructors[event_type](event_type)
-    except KeyError:
-        event = Gdk.Event.new(event_type)
-
+    constructor = event_types_constructors[event_type]
+    event = constructor()
+    event.type = event_type
     for arg, value in kwargs.items():
         setattr(event, arg, value)
 
@@ -220,11 +219,11 @@ def _releaseButtonIfNeeded(scenario, action, timeline, container, edge, layer_pr
 
     if next_action is None or need_release:
         scenario.dragging = False
-        event = Gdk.EventButton.new(Gdk.EventType.BUTTON_RELEASE)
-        event.button = 1
-        event.x = timelineUtils.Zoomable.nsToPixelAccurate(position)
-        event.y = y
-        container.ui.sendFakeEvent(event, container.ui)
+        x = Zoomable.nsToPixelAccurate(position)
+        event = Event(Gdk.EventType.BUTTON_RELEASE, button=1, x=x, y=y)
+        with mock.patch.object(Gtk, "get_event_widget") as get_event_widget:
+            get_event_widget.return_value = container.ui
+            container.ui._button_release_event_cb(None, event)
 
         if layer_prio > 0 and container.get_layer().get_priority() != layer_prio:
             scenario.report_simple(GLib.quark_from_string("scenario::execution-error"),
@@ -238,18 +237,17 @@ def _releaseButtonIfNeeded(scenario, action, timeline, container, edge, layer_pr
 
 def cleanEditModes(timeline, scenario):
     if scenario.last_mode == GES.EditMode.EDIT_RIPPLE:
-        timeline.ui.sendFakeEvent(Event(Gdk.EventType.KEY_RELEASE, keyval=Gdk.KEY_Shift_L))
+        event = Event(Gdk.EventType.KEY_RELEASE, keyval=Gdk.KEY_Shift_L)
+        timeline.ui.get_parent().do_key_release_event(event)
     elif scenario.last_mode == GES.EditMode.EDIT_ROLL:
-        timeline.ui.sendFakeEvent(Event(Gdk.EventType.KEY_RELEASE, keyval=Gdk.KEY_Control_L))
+        event = Event(Gdk.EventType.KEY_RELEASE, keyval=Gdk.KEY_Control_L)
+        timeline.ui.get_parent().do_key_release_event(event)
 
     scenario.last_mode = None
 
 
 def setEditingMode(timeline, scenario, action):
-    try:
-        mode = scenario.last_mode
-        mode
-    except AttributeError:
+    if not hasattr(scenario, "last_mode"):
         scenario.last_mode = None
 
     try:
@@ -262,16 +260,16 @@ def setEditingMode(timeline, scenario, action):
         mode = GES.EditMode.EDIT_NORMAL
 
     if mode == GES.EditMode.EDIT_RIPPLE:
-        timeline.ui.sendFakeEvent(Event(Gdk.EventType.KEY_PRESS, keyval=Gdk.KEY_Shift_L))
+        timeline.ui.get_parent().do_key_press_event(Event(Gdk.EventType.KEY_PRESS, keyval=Gdk.KEY_Shift_L))
 
         if scenario.last_mode == GES.EditMode.EDIT_ROLL:
-            timeline.ui.sendFakeEvent(Event(Gdk.EventType.KEY_RELEASE, keyval=Gdk.KEY_Control_L))
+            timeline.ui.get_parent().do_key_release_event(Event(Gdk.EventType.KEY_RELEASE, 
keyval=Gdk.KEY_Control_L))
 
     elif mode == GES.EditMode.EDIT_ROLL:
-        timeline.ui.sendFakeEvent(Event(Gdk.EventType.KEY_PRESS, keyval=Gdk.KEY_Control_L))
+        timeline.ui.do_key_press_event(Event(Gdk.EventType.KEY_PRESS, keyval=Gdk.KEY_Control_L))
 
         if scenario.last_mode == GES.EditMode.EDIT_RIPPLE:
-            timeline.ui.sendFakeEvent(Event(Gdk.EventType.KEY_RELEASE, keyval=Gdk.KEY_Shift_L))
+            timeline.ui.do_key_release_event(Event(Gdk.EventType.KEY_RELEASE, keyval=Gdk.KEY_Shift_L))
     else:
         cleanEditModes(timeline, scenario)
 
@@ -332,25 +330,26 @@ def editContainer(scenario, action):
 
     if not hasattr(scenario, "dragging") or scenario.dragging is False \
             or scenario.last_edge != edge:
-        widget = container.ui
         event_widget = container.ui
         if isinstance(container, GES.SourceClip):
             if edge == GES.Edge.EDGE_START:
                 event_widget = container.ui.leftHandle
-                event = timeline
             elif edge == GES.Edge.EDGE_END:
                 event_widget = container.ui.rightHandle
-                event = timeline
 
         scenario.dragging = True
         event = Event(Gdk.EventType.BUTTON_PRESS, button=1, y=y)
-        widget.sendFakeEvent(event, event_widget)
+        with mock.patch.object(Gtk, "get_event_widget") as get_event_widget:
+            get_event_widget.return_value = event_widget
+            timeline.ui._button_press_event_cb(event_widget, event)
 
     event = Event(Gdk.EventType.MOTION_NOTIFY, button=1,
-                  x=timelineUtils.Zoomable.nsToPixelAccurate(position) -
-                  container_ui.translate_coordinates(timeline.ui, 0, 0)[0] + ui.CONTROL_WIDTH,
+                  x=Zoomable.nsToPixelAccurate(position) -
+                  container_ui.translate_coordinates(timeline.ui, 0, 0)[0] + timeline.ui.controls_width,
                   y=y, state=Gdk.ModifierType.BUTTON1_MASK)
-    container.ui.sendFakeEvent(event, container.ui)
+    with mock.patch.object(Gtk, "get_event_widget") as get_event_widget:
+        get_event_widget.return_value = container.ui
+        timeline.ui._motion_notify_event_cb(None, event)
 
     GstValidate.print_action(action, "Editing %s to %s in %s mode, edge: %s "
                              "with new layer prio: %d\n" % (action.structure["container-name"],
@@ -384,14 +383,14 @@ def zoom(scenario, action):
     GstValidate.print_action(action, action.type.replace('-', ' ') + "\n")
 
     {"zoom-fit": timeline.parent.zoomFit,
-     "zoom-out": timelineUtils.Zoomable.zoomOut,
-     "zoom-in": timelineUtils.Zoomable.zoomIn}[action.type]()
+     "zoom-out": Zoomable.zoomOut,
+     "zoom-in": Zoomable.zoomIn}[action.type]()
 
     return True
 
 
 def setZoomLevel(scenario, action):
-    timelineUtils.Zoomable.setZoomLevel(action.structure["level"])
+    Zoomable.setZoomLevel(action.structure["level"])
 
     return True
 
@@ -446,11 +445,13 @@ def select_clips(scenario, action):
         if clip.ui.get_state_flags() & Gtk.StateFlags.SELECTED:
             should_select = False
 
-        timeline.ui.sendFakeEvent(Event(event_type=Gdk.EventType.KEY_PRESS,
-                                        keyval=Gdk.KEY_Control_L))
+        event = Event(Gdk.EventType.KEY_PRESS, keyval=Gdk.KEY_Control_L)
+        timeline.ui.get_parent().do_key_press_event(event)
 
-    event = Gdk.EventButton.new(Gdk.EventType.BUTTON_RELEASE)
-    clip.ui.sendFakeEvent(event, clip.ui)
+    event = Event(Gdk.EventType.BUTTON_RELEASE, button=1)
+    with mock.patch.object(Gtk, "get_event_widget") as get_event_widget:
+        get_event_widget.return_value = clip.ui
+        clip.ui._button_release_event_cb(None, event)
 
     selection = action.structure["selection"]
     if not selection:
@@ -478,7 +479,8 @@ def select_clips(scenario, action):
                                                " but it is" % (selection, clip.get_name()))
 
     if mode == "ctrl":
-        timeline.ui.sendFakeEvent(Event(Gdk.EventType.KEY_RELEASE, keyval=Gdk.KEY_Control_L))
+        event = Event(Gdk.EventType.KEY_RELEASE, keyval=Gdk.KEY_Control_L)
+        timeline.ui.get_parent().do_key_release_event(event)
 
     return 1
 
@@ -522,7 +524,7 @@ def init():
 
         GstValidate.register_action_type("set-state", "pitivi",
                                          set_state, None,
-                                         "Pitivi override for the pause action",
+                                         "Pitivi override for the set-state action",
                                          GstValidate.ActionTypeFlags.NONE)
 
         GstValidate.register_action_type("edit-container", "pitivi",
diff --git a/tests/common.py b/tests/common.py
index d2b6b02..1afe84a 100644
--- a/tests/common.py
+++ b/tests/common.py
@@ -26,7 +26,6 @@ import tempfile
 import unittest
 from unittest import mock
 
-from gi.repository import Gdk
 from gi.repository import GLib
 from gi.repository import Gst
 from gi.repository import Gtk
@@ -39,7 +38,6 @@ from pitivi.utils.loggable import Loggable
 from pitivi.utils.proxy import ProxyingStrategy
 from pitivi.utils.proxy import ProxyManager
 from pitivi.utils.timeline import Selected
-from pitivi.utils.validate import Event
 
 detect_leaks = os.environ.get("PITIVI_TEST_DETECT_LEAKS", "0") not in ("0", "")
 os.environ["PITIVI_USER_CACHE_DIR"] = tempfile.mkdtemp("pitiviTestsuite")
@@ -179,17 +177,18 @@ class TestCase(unittest.TestCase, Loggable):
         self._result = result
         unittest.TestCase.run(self, result)
 
-    def toggleClipSelection(self, ges_clip, expect_selected):
-        '''
-        Toggle selection state of @ges_clip.
-        '''
+    def toggle_clip_selection(self, ges_clip, expect_selected):
+        """Toggles the selection state of @ges_clip."""
         selected = bool(ges_clip.ui.get_state_flags() & Gtk.StateFlags.SELECTED)
         self.assertEqual(ges_clip.selected.selected, selected)
 
-        ges_clip.ui.sendFakeEvent(
-            Event(Gdk.EventType.BUTTON_PRESS, button=1), ges_clip.ui)
-        ges_clip.ui.sendFakeEvent(
-            Event(Gdk.EventType.BUTTON_RELEASE, button=1), ges_clip.ui)
+        # Simulate a click on the clip.
+        event = mock.Mock()
+        event.get_button.return_value = (True, 1)
+        with mock.patch.object(Gtk, "get_event_widget") as get_event_widget:
+            get_event_widget.return_value = ges_clip.ui
+            ges_clip.ui.timeline._button_press_event_cb(None, event)
+        ges_clip.ui._button_release_event_cb(None, event)
 
         self.assertEqual(bool(ges_clip.ui.get_state_flags() & Gtk.StateFlags.SELECTED),
                          expect_selected)
diff --git a/tests/test_timeline_timeline.py b/tests/test_timeline_timeline.py
index dc87c03..0469670 100644
--- a/tests/test_timeline_timeline.py
+++ b/tests/test_timeline_timeline.py
@@ -25,7 +25,6 @@ from gi.repository import Gtk
 from pitivi.project import ProjectManager
 from pitivi.timeline.timeline import TimelineContainer
 from pitivi.utils import ui
-from pitivi.utils.validate import Event
 from tests import common
 
 
@@ -165,12 +164,13 @@ class TestGrouping(BaseTestTimeline):
         timeline.app.settings.leftClickAlsoSeeks = False
 
         # Press <ctrl> so selecting in ADD mode
-        timeline.sendFakeEvent(Event(event_type=Gdk.EventType.KEY_PRESS,
-                                     keyval=Gdk.KEY_Control_L))
+        event = mock.Mock()
+        event.keyval = Gdk.KEY_Control_L
+        timeline.parent.do_key_press_event(event)
 
         # Select the 2 clips
         for clip in clips:
-            self.toggleClipSelection(clip, expect_selected=True)
+            self.toggle_clip_selection(clip, expect_selected=True)
 
         before_grouping_timeline_group = timeline.current_group
 
@@ -211,7 +211,7 @@ class TestGrouping(BaseTestTimeline):
         self.assertEqual(len(clips), num_clips)
 
         # Deselect one grouped clip clips
-        self.toggleClipSelection(clips[0], expect_selected=False)
+        self.toggle_clip_selection(clips[0], expect_selected=False)
 
         # Make sure all the clips have been deselected
         for clip in clips:
@@ -239,7 +239,7 @@ class TestGrouping(BaseTestTimeline):
 
         timeline = self.createTimeline()
         clips = self.addClipsSimple(timeline, 1)
-        self.toggleClipSelection(clips[0], expect_selected=True)
+        self.toggle_clip_selection(clips[0], expect_selected=True)
 
         timeline.ges_timeline.get_asset().pipeline.getPosition = mock.Mock(return_value=position)
         layer = timeline.ges_timeline.get_layers()[0]
@@ -254,11 +254,11 @@ class TestGrouping(BaseTestTimeline):
         self.assertTrue(clips[0].selected.selected)
         self.assertFalse(clips[1].selected.selected)
 
-        timeline.sendFakeEvent(Event(event_type=Gdk.EventType.KEY_PRESS,
-                                     keyval=Gdk.KEY_Control_L))
-        self.toggleClipSelection(clips[1], expect_selected=True)
-        timeline.sendFakeEvent(Event(event_type=Gdk.EventType.KEY_RELEASE,
-                                     keyval=Gdk.KEY_Control_L))
+        event = mock.Mock()
+        event.keyval = Gdk.KEY_Control_L
+        timeline.parent.do_key_press_event(event)
+        self.toggle_clip_selection(clips[1], expect_selected=True)
+        timeline.parent.do_key_release_event(event)
 
         for clip in clips:
             self.assertTrue(clip.selected.selected)
@@ -266,13 +266,13 @@ class TestGrouping(BaseTestTimeline):
         # Group the two parts
         timeline.parent.group_action.emit("activate", None)
 
-        self.toggleClipSelection(clips[1], expect_selected=True)
+        self.toggle_clip_selection(clips[1], expect_selected=True)
 
     def testUngroupClip(self):
         timeline = self.createTimeline()
         ges_clip, = self.addClipsSimple(timeline, 1)
 
-        self.toggleClipSelection(ges_clip, expect_selected=True)
+        self.toggle_clip_selection(ges_clip, expect_selected=True)
 
         timeline.parent.ungroup_action.emit("activate", None)
         layer = timeline.ges_timeline.get_layers()[0]
@@ -312,7 +312,7 @@ class TestGrouping(BaseTestTimeline):
         self.group_clips(timeline, [clip1, clip2])
 
         # Click the first clip in the group.
-        with mock.patch.object(timeline, 'get_event_widget') as get_event_widget:
+        with mock.patch.object(Gtk, 'get_event_widget') as get_event_widget:
             event = mock.Mock()
             event.x = 0
             event.get_button.return_value = True, 1
@@ -346,12 +346,13 @@ class TestCopyPaste(BaseTestTimeline):
         clips = self.addClipsSimple(timeline, num_clips)
 
         # Press <ctrl> so selecting in ADD mode
-        timeline.sendFakeEvent(Event(event_type=Gdk.EventType.KEY_PRESS,
-                                     keyval=Gdk.KEY_Control_L))
+        event = mock.Mock()
+        event.keyval = Gdk.KEY_Control_L
+        timeline.parent.do_key_press_event(event)
 
         # Select the 2 clips
         for clip in clips:
-            self.toggleClipSelection(clip, expect_selected=True)
+            self.toggle_clip_selection(clip, expect_selected=True)
 
         self.assertTrue(timeline.parent.copy_action.props.enabled)
         self.assertFalse(timeline.parent.paste_action.props.enabled)
@@ -393,7 +394,7 @@ class TestEditing(BaseTestTimeline):
         layer = clip.get_layer()
 
         # Click the right trim handle of the clip.
-        with mock.patch.object(timeline, 'get_event_widget') as get_event_widget:
+        with mock.patch.object(Gtk, 'get_event_widget') as get_event_widget:
             event = mock.Mock()
             event.get_button.return_value = True, 1
             get_event_widget.return_value = clip.ui.rightHandle
diff --git a/tests/test_undo_timeline.py b/tests/test_undo_timeline.py
index 830762f..1ddcfe1 100644
--- a/tests/test_undo_timeline.py
+++ b/tests/test_undo_timeline.py
@@ -167,7 +167,7 @@ class TestLayerObserver(BaseTestUndoTimeline):
         timeline_ui.setProject(self.app.project_manager.current_project)
 
         # Click and drag a layer control box to move the layer.
-        with mock.patch.object(timeline_ui, 'get_event_widget') as get_event_widget:
+        with mock.patch.object(Gtk, 'get_event_widget') as get_event_widget:
             event = mock.Mock()
             event.get_button.return_value = True, 1
 
@@ -687,19 +687,23 @@ class TestDragDropUndo(BaseTestUndoTimeline):
         self.layer.add_clip(clip)
 
         # Drag a clip on a separator to create a layer.
-        timeline_ui.get_event_widget = mock.Mock(return_value=clip.ui)
-        event = mock.Mock()
-        event.x = 0
-        event.get_button.return_value = True, 1
-        timeline_ui._button_press_event_cb(None, event)
-
-        def translate_coordinates(widget, x, y):
-            return x, y
-        clip.ui.translate_coordinates = translate_coordinates
-        event.get_state.return_value = Gdk.ModifierType.BUTTON1_MASK
-        event.x = 1
-        event.y = LAYER_HEIGHT * 2
-        timeline_ui._motion_notify_event_cb(None, event)
+        with mock.patch.object(Gtk, 'get_event_widget') as get_event_widget:
+            get_event_widget.return_value = clip.ui
+
+            event = mock.Mock()
+            event.x = 0
+            event.get_button.return_value = True, 1
+            timeline_ui._button_press_event_cb(None, event)
+
+            def translate_coordinates(widget, x, y):
+                return x, y
+            clip.ui.translate_coordinates = translate_coordinates
+            event = mock.Mock()
+            event.get_state.return_value = Gdk.ModifierType.BUTTON1_MASK
+            event.x = 1
+            event.y = LAYER_HEIGHT * 2
+            event.get_button.return_value = True, 1
+            timeline_ui._motion_notify_event_cb(None, event)
 
         timeline_ui._button_release_event_cb(None, event)