def test_scaled_proxy_size(self):
app = common.create_pitivi_mock(default_scaled_proxy_width=123,
default_scaled_proxy_height=456)
manager = ProjectManager(app)
project = manager.new_blank_project()
self.assertFalse(project.has_scaled_proxy_size())
self.assertEqual(project.scaled_proxy_width, 123)
self.assertEqual(project.scaled_proxy_height, 456)
with tempfile.NamedTemporaryFile() as temp_file:
uri = Gst.filename_to_uri(temp_file.name)
manager.save_project(uri=uri, backup=False)
app2 = common.create_pitivi_mock(default_scaled_proxy_width=12,
default_scaled_proxy_height=45)
project2 = ProjectManager(app2).load_project(uri)
self.assertFalse(project2.has_scaled_proxy_size())
self.assertEqual(project2.scaled_proxy_width, 12)
self.assertEqual(project2.scaled_proxy_height, 45)
project.scaled_proxy_width = 123
project.scaled_proxy_height = 456
self.assertTrue(project.has_scaled_proxy_size())
self.assertEqual(project.scaled_proxy_width, 123)
self.assertEqual(project.scaled_proxy_height, 456)
with tempfile.NamedTemporaryFile() as temp_file:
manager.save_project(uri=uri, backup=False)
app2 = common.create_pitivi_mock(default_scaled_proxy_width=1,
default_scaled_proxy_height=4)
project2 = ProjectManager(app2).load_project(uri)
self.assertTrue(project2.has_scaled_proxy_size())
self.assertEqual(project2.scaled_proxy_width, 123)
self.assertEqual(project2.scaled_proxy_height, 456)
def test_prop_reset(self):
"""Checks the reset button resets the property."""
self.app = common.create_pitivi_mock()
self._register_alpha_widget(
("black_sens_adjustment", "GstAlpha::black-sensitivity",
"GstAlpha::black-sensitivity::reset", "image1"))
wrapped_spin_button = self.element_settings_widget.properties[
self.prop]
_, prop_value = self.alpha_effect.get_child_property(self.prop_name)
self.assertEqual(self.prop.default_value, prop_value)
self.assertEqual(self.prop.default_value,
wrapped_spin_button.getWidgetValue())
# Set the property value to a different value than the default
wrapped_spin_button.setWidgetValue(
(1 + self.prop.default_value) % self.prop.maximum)
_, prop_value = self.alpha_effect.get_child_property(self.prop_name)
self.assertEqual(prop_value,
(1 + self.prop.default_value) % self.prop.maximum)
# Reset the value of the property to default
prop_reset_button = \
list(self.element_settings_widget._GstElementSettingsWidget__widgets_by_reset_button.keys())[0]
prop_reset_button.clicked()
_, prop_value = self.alpha_effect.get_child_property(self.prop_name)
self.assertEqual(self.prop.default_value, prop_value)
self.assertEqual(self.prop.default_value,
wrapped_spin_button.getWidgetValue())
def test_recovery(self):
"""Checks the recovery mechanism."""
pipe = Pipeline(common.create_pitivi_mock())
pipe.set_timeline(GES.Timeline())
pipeline_died_cb = mock.Mock()
pipe.connect("died", pipeline_died_cb)
with mock.patch.object(pipe, "set_state") as set_state:
pipe.pause()
set_state.assert_called_once_with(Gst.State.PAUSED)
self.assertEqual(pipe._attempted_recoveries, 0)
self.assertFalse(pipeline_died_cb.called)
for i in range(MAX_RECOVERIES):
with mock.patch.object(pipe, "set_state") as set_state:
set_state.return_value = Gst.StateChangeReturn.SUCCESS
self.post_fake_error_message(pipe)
set_state.assert_has_calls(
[mock.call(Gst.State.NULL),
mock.call(Gst.State.PAUSED)])
self.assertEqual(set_state.call_count, 2)
self.assertEqual(pipe._attempted_recoveries, i + 1)
self.assertFalse(pipeline_died_cb.called)
with mock.patch.object(pipe, "set_state") as set_state:
self.post_fake_error_message(pipe)
set_state.assert_not_called()
self.assertTrue(pipeline_died_cb.called)
self.assertEqual(pipe._attempted_recoveries, MAX_RECOVERIES)
def __loading_failure(self, has_proxy):
mainloop = common.create_main_loop()
app = common.create_pitivi_mock(lastProjectFolder="/tmp",
edgeSnapDeadband=32)
app.project_manager = ProjectManager(app)
mainwindow = MainWindow(app)
mainwindow.viewer = mock.MagicMock()
def __pm_missing_uri_cb(project_manager, project,
error, asset):
nonlocal mainloop
nonlocal mainwindow
nonlocal self
nonlocal app
nonlocal has_proxy
with mock.patch('gi.repository.Gtk.Dialog') as dialog:
failed_cb = mock.MagicMock()
app.project_manager.connect("new-project-failed", failed_cb)
dialog.return_value = mock.MagicMock()
dialog.return_value.run = mock.MagicMock(
return_value=Gtk.ResponseType.CLOSE)
# Call the actual callback
# pylint: disable=protected-access
app.proxy_manager.checkProxyLoadingSucceeded = \
mock.MagicMock(return_value=has_proxy)
mainwindow._projectManagerMissingUriCb(
project_manager, project, error, asset)
self.assertTrue(dialog.called)
self.assertTrue(dialog.return_value.run.called)
self.assertEqual(failed_cb.called, not has_proxy)
# pylint: disable=protected-access
app.project_manager.connect("missing-uri",
mainwindow._projectManagerMissingUriCb)
# pylint: disable=protected-access
app.project_manager.connect("new-project-failed",
mainwindow._projectManagerNewProjectFailedCb)
mainwindow.destroy()
mainloop.quit()
# pylint: disable=protected-access
disconnectAllByFunc(app.project_manager,
mainwindow._projectManagerMissingUriCb)
disconnectAllByFunc(app.project_manager,
mainwindow._projectManagerNewProjectFailedCb)
app.project_manager.connect("missing-uri",
__pm_missing_uri_cb)
with common.created_project_file() as uri:
app.project_manager.loadProject(uri)
mainloop.run()
def test_transition_types_loaded(self):
"""Checks the transition types are properly detected."""
app = common.create_pitivi_mock()
widget = TransitionsListWidget(app)
mainloop = common.create_main_loop()
mainloop.run(until_empty=True)
self.assertGreater(len(widget.storemodel), 10)
def test_async_done_not_received(self):
"""Checks the recovery when the ASYNC_DONE message timed out."""
ges_timeline = GES.Timeline.new()
self.assertTrue(ges_timeline.add_track(GES.VideoTrack.new()))
ges_layer = ges_timeline.append_layer()
uri = common.get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
ges_clip = asset.extract()
self.assertTrue(ges_layer.add_clip(ges_clip))
self.assertFalse(ges_timeline.is_empty())
pipe = Pipeline(app=common.create_pitivi_mock())
pipe.set_timeline(ges_timeline)
self.assertFalse(pipe._busy_async)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.NOT_RECOVERING)
# Pretend waiting for async-done timed out.
# We mock set_state because we don't actually care about the state,
# and setting the state to PAUSED could show a video window.
with mock.patch.object(pipe, "set_state"):
pipe._async_done_not_received_cb()
# Make sure the pipeline started a watchdog timer waiting for async-done
# as part of setting the state from NULL to PAUSED.
self.assertTrue(pipe._busy_async)
self.assertEqual(pipe._attempted_recoveries, 1)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.STARTED_RECOVERING)
# Pretend the state changed to READY.
message = mock.Mock()
message.type = Gst.MessageType.STATE_CHANGED
message.src = pipe._pipeline
message.parse_state_changed.return_value = (Gst.State.NULL, Gst.State.READY, Gst.State.PAUSED)
pipe._busMessageCb(None, message)
# Pretend the state changed to PAUSED.
message.parse_state_changed.return_value = (Gst.State.READY, Gst.State.PAUSED, Gst.State.VOID_PENDING)
self.assertEqual(pipe._next_seek, None)
pipe._busMessageCb(None, message)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.SEEKED_AFTER_RECOVERING)
self.assertTrue(pipe._busy_async)
# The pipeline should have tried to seek back to the last position.
self.assertEqual(pipe._next_seek, 0)
# Pretend the state change (to PAUSED) async operation succeeded.
message.type = Gst.MessageType.ASYNC_DONE
with mock.patch.object(pipe, "get_state") as get_state:
get_state.return_value = (0, Gst.State.PAUSED, 0)
pipe._busMessageCb(None, message)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.NOT_RECOVERING)
# Should still be busy because of seeking to _next_seek.
self.assertTrue(pipe._busy_async)
self.assertIsNone(pipe._next_seek)
# Pretend the seek async operation finished.
message.type = Gst.MessageType.ASYNC_DONE
pipe._busMessageCb(None, message)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.NOT_RECOVERING)
self.assertFalse(pipe._busy_async)
self.assertIsNone(pipe._next_seek)
def test_recovery(self):
"""Checks the recovery mechanism."""
pipe = Pipeline(common.create_pitivi_mock())
pipe.set_timeline(GES.Timeline())
pipeline_died_cb = mock.Mock()
pipe.connect("died", pipeline_died_cb)
with mock.patch.object(pipe, "set_state") as set_state:
pipe.pause()
set_state.assert_called_once_with(Gst.State.PAUSED)
self.assertEqual(pipe._attempted_recoveries, 0)
self.assertFalse(pipeline_died_cb.called)
for i in range(MAX_RECOVERIES):
with mock.patch.object(pipe, "set_state") as set_state:
set_state.return_value = Gst.StateChangeReturn.SUCCESS
self.post_fake_error_message(pipe)
set_state.assert_has_calls([mock.call(Gst.State.NULL),
mock.call(Gst.State.PAUSED)])
self.assertEqual(set_state.call_count, 2)
self.assertEqual(pipe._attempted_recoveries, i + 1)
self.assertFalse(pipeline_died_cb.called)
with mock.patch.object(pipe, "set_state") as set_state:
self.post_fake_error_message(pipe)
set_state.assert_not_called()
self.assertTrue(pipeline_died_cb.called)
self.assertEqual(pipe._attempted_recoveries, MAX_RECOVERIES)
def __loading_failure(self, has_proxy):
mainloop = common.create_main_loop()
app = common.create_pitivi_mock(lastProjectFolder="/tmp",
edgeSnapDeadband=32)
app.project_manager = ProjectManager(app)
mainwindow = MainWindow(app)
mainwindow.viewer = mock.MagicMock()
def __pm_missing_uri_cb(project_manager, project, error, asset):
nonlocal mainloop
nonlocal mainwindow
nonlocal self
nonlocal app
nonlocal has_proxy
with mock.patch('gi.repository.Gtk.Dialog') as dialog:
failed_cb = mock.MagicMock()
app.project_manager.connect("new-project-failed", failed_cb)
dialog.return_value = mock.MagicMock()
dialog.return_value.run = mock.MagicMock(
return_value=Gtk.ResponseType.CLOSE)
# Call the actual callback
# pylint: disable=protected-access
app.proxy_manager.checkProxyLoadingSucceeded = \
mock.MagicMock(return_value=has_proxy)
mainwindow._projectManagerMissingUriCb(project_manager,
project, error, asset)
self.assertTrue(dialog.called)
self.assertTrue(dialog.return_value.run.called)
self.assertEqual(failed_cb.called, not has_proxy)
# pylint: disable=protected-access
app.project_manager.connect("missing-uri",
mainwindow._projectManagerMissingUriCb)
# pylint: disable=protected-access
app.project_manager.connect(
"new-project-failed",
mainwindow._projectManagerNewProjectFailedCb)
mainwindow.destroy()
mainloop.quit()
# pylint: disable=protected-access
disconnectAllByFunc(app.project_manager,
mainwindow._projectManagerMissingUriCb)
disconnectAllByFunc(app.project_manager,
mainwindow._projectManagerNewProjectFailedCb)
app.project_manager.connect("missing-uri", __pm_missing_uri_cb)
with common.created_project_file() as uri:
app.project_manager.loadProject(uri)
mainloop.run()
def test_name(self):
project = Project(common.create_pitivi_mock())
project.uri = "file:///tmp/A%20B.xges"
self.assertEqual(project.name, "A B")
project.uri = "file:///tmp/%40%23%24%5E%26%60.xges"
self.assertEqual(project.name, "@#$^&`")
def test_name(self):
project = Project(common.create_pitivi_mock())
project.uri = "file:///tmp/A%20B.xges"
self.assertEqual(project.name, "A B")
project.uri = "file:///tmp/%40%23%24%5E%26%60.xges"
self.assertEqual(project.name, "@#$^&`")
def __loading_failure(self, has_proxy):
mainloop = common.create_main_loop()
app = common.create_pitivi_mock(lastProjectFolder="/tmp",
edgeSnapDeadband=32)
app.project_manager = ProjectManager(app)
editorperspective = EditorPerspective(app)
editorperspective.setup_ui()
editorperspective.viewer = mock.MagicMock()
editorperspective.medialibrary._import_warning_infobar = mock.MagicMock(
)
editorperspective.clipconfig.effect_expander._infobar = mock.MagicMock(
)
def __pm_missing_uri_cb(project_manager, project, error, asset):
nonlocal mainloop
nonlocal editorperspective
nonlocal self
nonlocal app
nonlocal has_proxy
with mock.patch.object(MissingAssetDialog,
"__new__") as constructor:
failed_cb = mock.MagicMock()
app.project_manager.connect("new-project-failed", failed_cb)
dialog = constructor.return_value
dialog.get_new_uri.return_value = None
# Call the actual callback
app.proxy_manager.checkProxyLoadingSucceeded = \
mock.MagicMock(return_value=has_proxy)
editorperspective._projectManagerMissingUriCb(
project_manager, project, error, asset)
self.assertTrue(constructor.called)
self.assertTrue(dialog.get_new_uri.called)
self.assertEqual(failed_cb.called, not has_proxy)
app.project_manager.connect(
"missing-uri", editorperspective._projectManagerMissingUriCb)
mainloop.quit()
disconnectAllByFunc(app.project_manager,
editorperspective._projectManagerMissingUriCb)
app.project_manager.connect("missing-uri", __pm_missing_uri_cb)
with common.cloned_sample():
asset_uri = common.get_sample_uri("missing.png")
with common.created_project_file(asset_uri) as uri:
app.project_manager.load_project(uri)
mainloop.run()
def __loading_failure(self, has_proxy):
mainloop = common.create_main_loop()
app = common.create_pitivi_mock(lastProjectFolder="/tmp",
edgeSnapDeadband=32)
app.project_manager = ProjectManager(app)
editorperspective = EditorPerspective(app)
editorperspective.setup_ui()
editorperspective.viewer = mock.MagicMock()
editorperspective.medialibrary._import_warning_infobar = mock.MagicMock()
editorperspective.clipconfig.effect_expander._infobar = mock.MagicMock()
def __pm_missing_uri_cb(project_manager, project, error, asset):
nonlocal mainloop
nonlocal editorperspective
nonlocal self
nonlocal app
nonlocal has_proxy
with mock.patch.object(MissingAssetDialog, "__new__") as constructor:
failed_cb = mock.MagicMock()
app.project_manager.connect("new-project-failed", failed_cb)
dialog = constructor.return_value
dialog.get_new_uri.return_value = None
# Call the actual callback
app.proxy_manager.checkProxyLoadingSucceeded = \
mock.MagicMock(return_value=has_proxy)
editorperspective._projectManagerMissingUriCb(
project_manager, project, error, asset)
self.assertTrue(constructor.called)
self.assertTrue(dialog.get_new_uri.called)
self.assertEqual(failed_cb.called, not has_proxy)
app.project_manager.connect("missing-uri",
editorperspective._projectManagerMissingUriCb)
mainloop.quit()
disconnectAllByFunc(app.project_manager,
editorperspective._projectManagerMissingUriCb)
app.project_manager.connect("missing-uri", __pm_missing_uri_cb)
with common.cloned_sample():
asset_uri = common.get_sample_uri("missing.png")
with common.created_project_file(asset_uri) as uri:
app.project_manager.load_project(uri)
mainloop.run()
def test_switch_context_tab(self):
"""Checks tab switches."""
app = common.create_pitivi_mock()
editorperspective = EditorPerspective(app)
editorperspective.setup_ui()
for expected_tab, b_element in [(2, GES.TitleClip()),
(0, GES.SourceClip()),
(1, GES.TransitionClip())]:
editorperspective.switchContextTab(b_element)
self.assertEqual(editorperspective.context_tabs.get_current_page(),
expected_tab, b_element)
# Make sure the tab does not change when using an invalid argument.
editorperspective.switchContextTab("invalid")
self.assertEqual(editorperspective.context_tabs.get_current_page(),
expected_tab)
def createTimeline(self):
app = common.create_pitivi_mock()
project_manager = ProjectManager(app)
project_manager.newBlankProject()
project = project_manager.current_project
timeline_container = TimelineContainer(app)
timeline_container.setProject(project)
timeline = timeline_container.timeline
timeline.get_parent = mock.MagicMock()
timeline.app.settings.leftClickAlsoSeeks = False
return timeline
def test_switch_context_tab(self):
"""Checks tab switches."""
app = common.create_pitivi_mock()
mainwindow = MainWindow(app)
for expected_tab, b_element in [(2, GES.TitleClip()),
(0, GES.SourceClip()),
(1, GES.TransitionClip())]:
mainwindow.switchContextTab(b_element)
self.assertEqual(mainwindow.context_tabs.get_current_page(),
expected_tab, b_element)
# Make sure the tab does not change when using an invalid argument.
mainwindow.switchContextTab("invalid")
self.assertEqual(mainwindow.context_tabs.get_current_page(),
expected_tab)
mainwindow.destroy()
def createTimeline(self):
app = common.create_pitivi_mock()
project_manager = ProjectManager(app)
project_manager.newBlankProject()
project = project_manager.current_project
timeline_container = TimelineContainer(app)
timeline_container.setProject(project)
timeline = timeline_container.timeline
timeline.app.project_manager.current_project = project
timeline.get_parent = mock.MagicMock(return_value=timeline_container)
timeline.app.settings.leftClickAlsoSeeks = False
return timeline
def test_switch_context_tab(self):
"""Checks tab switches."""
app = common.create_pitivi_mock()
editorperspective = EditorPerspective(app)
editorperspective.setup_ui()
for expected_tab, b_element in [
(2, GES.TitleClip()),
(0, GES.SourceClip()),
(1, GES.TransitionClip())]:
editorperspective.switchContextTab(b_element)
self.assertEqual(editorperspective.context_tabs.get_current_page(),
expected_tab,
b_element)
# Make sure the tab does not change when using an invalid argument.
editorperspective.switchContextTab("invalid")
self.assertEqual(editorperspective.context_tabs.get_current_page(),
expected_tab)
def testMissingUriForwarded(self):
self.setupApp(app=common.create_pitivi_mock())
mainloop = common.create_main_loop()
def missingUriCb(self, project, error, clip_asset, result):
result[0] = True
mainloop.quit()
result = [False]
self.manager.connect("missing-uri", missingUriCb, result)
with common.cloned_sample():
asset_uri = common.get_sample_uri("missing.png")
with common.created_project_file(asset_uri) as uri:
self.assertIsNotNone(self.manager.load_project(uri))
mainloop.run()
self.assertTrue(result[0], "missing-uri has not been emitted")
def testMissingUriForwarded(self):
self.setupApp(app=common.create_pitivi_mock())
mainloop = common.create_main_loop()
def missingUriCb(self, project, error, clip_asset, result):
result[0] = True
mainloop.quit()
result = [False]
self.manager.connect("missing-uri", missingUriCb, result)
with common.cloned_sample():
asset_uri = common.get_sample_uri("missing.png")
with common.created_project_file(asset_uri) as uri:
self.assertIsNotNone(self.manager.load_project(uri))
mainloop.run()
self.assertTrue(result[0], "missing-uri has not been emitted")
def test_toggle_safe_areas_action(self):
"""Checks the effect of the toggle_safe_areas_action."""
app = common.create_pitivi_mock()
app.project_manager = ProjectManager(app)
viewer_container = ViewerContainer(app)
project = app.project_manager.new_blank_project()
viewer_container.set_project(project)
self.assertFalse(
viewer_container.overlay_stack.safe_areas_overlay.get_visible())
viewer_container.toggle_safe_areas_action.activate()
self.assertTrue(
viewer_container.overlay_stack.safe_areas_overlay.get_visible())
viewer_container.toggle_safe_areas_action.activate()
self.assertFalse(
viewer_container.overlay_stack.safe_areas_overlay.get_visible())
def test_wrapping(self):
"""Checks UI updating results in updating the effect."""
self.app = common.create_pitivi_mock()
self._register_alpha_widget(("black_sens_adjustment", "GstAlpha::black-sensitivity"))
# Check if the widget is wrapped correctly
wrapped_spin_button = self.element_settings_widget.properties[self.prop]
self.assertTrue(isinstance(wrapped_spin_button, DynamicWidget))
self.assertTrue(isinstance(wrapped_spin_button, NumericWidget))
# Check if the wrapper has the correct default value
self.assertEqual(self.prop.default_value, wrapped_spin_button.getWidgetDefault())
# Check if the callbacks are functioning
value = (1 + self.prop.default_value) % self.prop.maximum
wrapped_spin_button.setWidgetValue(value)
self.assertEqual(wrapped_spin_button.getWidgetValue(), value)
_, prop_value = self.alpha_effect.get_child_property(self.prop_name)
self.assertEqual(prop_value, value)
def _customSetUp(self, project_uri=None, **kwargs):
# Always make sure we start with a clean medialibrary, and no other
# is connected to some assets.
self.clean()
self.mainloop = common.create_main_loop()
self.check_no_transcoding = False
self.app = common.create_pitivi_mock(**kwargs)
self.app.project_manager = ProjectManager(self.app)
self.medialibrary = medialibrary.MediaLibraryWidget(self.app)
if project_uri:
self.app.project_manager.load_project(project_uri)
else:
self.app.project_manager.new_blank_project()
self.app.project_manager.current_project.connect(
"loaded", self.projectLoadedCb)
self.mainloop.run()
def _custom_set_up(self, project_uri=None, **settings):
# Always make sure we start with a clean medialibrary, and no other
# is connected to some assets.
self.clean()
self.mainloop = common.create_main_loop()
self.check_no_transcoding = False
self.app = common.create_pitivi_mock(**settings)
self.app.project_manager = ProjectManager(self.app)
self.medialibrary = MediaLibraryWidget(self.app)
if project_uri:
self.app.project_manager.load_project(project_uri)
else:
self.app.project_manager.new_blank_project()
self.app.project_manager.current_project.connect(
"loaded", self.project_loaded_cb)
self.mainloop.run()
def test_wrapping(self):
"""Checks UI updating results in updating the effect."""
self.app = common.create_pitivi_mock()
self._register_alpha_widget(("black_sens_adjustment", "GstAlpha::black-sensitivity"))
# Check if the widget is wrapped correctly
wrapped_spin_button = self.element_settings_widget.properties[self.prop]
self.assertTrue(isinstance(wrapped_spin_button, DynamicWidget))
self.assertTrue(isinstance(wrapped_spin_button, NumericWidget))
# Check if the wrapper has the correct default value
self.assertEqual(self.prop.default_value, wrapped_spin_button.get_widget_default())
# Check if the callbacks are functioning
value = (1 + self.prop.default_value) % self.prop.maximum
wrapped_spin_button.set_widget_value(value)
self.assertEqual(wrapped_spin_button.get_widget_value(), value)
_, prop_value = self.alpha_effect.get_child_property(self.prop_name)
self.assertEqual(prop_value, value)
def _customSetUp(self, project_uri=None, **kwargs):
# Always make sure we start with a clean medialibrary, and no other
# is connected to some assets.
self.clean()
self.mainloop = common.create_main_loop()
self.check_no_transcoding = False
self.app = common.create_pitivi_mock(**kwargs)
self.app.project_manager = ProjectManager(self.app)
self.medialibrary = medialibrary.MediaLibraryWidget(self.app)
if project_uri:
self.app.project_manager.loadProject(project_uri)
else:
self.app.project_manager.newBlankProject(
ignore_unsaved_changes=True)
self.app.project_manager.current_project.connect(
"loaded", self.projectLoadedCb)
self.mainloop.run()
def testSwitchContextTab(self):
"""
Test tab switches
"""
app = common.create_pitivi_mock()
mainwindow = MainWindow(app)
for expected_tab, b_element in [
(2, GES.TitleClip()),
(0, GES.SourceClip()),
(1, GES.TransitionClip())]:
mainwindow.switchContextTab(b_element)
self.assertEqual(expected_tab,
mainwindow.context_tabs.get_current_page(),
b_element)
# Make sure the tab does not change when using an invalid argument.
mainwindow.switchContextTab("invalid")
self.assertEqual(
expected_tab, mainwindow.context_tabs.get_current_page())
mainwindow.destroy()
def test_commit_timeline_after(self):
"""Checks the recovery mechanism."""
pipe = Pipeline(common.create_pitivi_mock())
timeline = GES.Timeline()
pipe.set_timeline(timeline)
with mock.patch.object(pipe, "getState") as get_state:
get_state.return_value = (0, Gst.State.PAUSED, 0)
with mock.patch.object(timeline, "commit") as commit:
with pipe.commit_timeline_after():
pipe.commit_timeline()
self.assertEqual(commit.call_count, 1)
with mock.patch.object(timeline, "commit") as commit:
with pipe.commit_timeline_after():
self.assertEqual(pipe._prevent_commits, 1)
with pipe.commit_timeline_after():
self.assertEqual(pipe._prevent_commits, 2)
pipe.commit_timeline()
self.assertEqual(commit.call_count, 0)
self.assertEqual(commit.call_count, 1)
def test_commit_timeline_after(self):
"""Checks the recovery mechanism."""
pipe = Pipeline(common.create_pitivi_mock())
timeline = GES.Timeline()
pipe.set_timeline(timeline)
with mock.patch.object(pipe, "get_state") as get_state:
get_state.return_value = (0, Gst.State.PAUSED, 0)
with mock.patch.object(timeline, "commit") as commit:
with pipe.commit_timeline_after():
pipe.commit_timeline()
self.assertEqual(commit.call_count, 1)
with mock.patch.object(timeline, "commit") as commit:
with pipe.commit_timeline_after():
self.assertEqual(pipe._prevent_commits, 1)
with pipe.commit_timeline_after():
self.assertEqual(pipe._prevent_commits, 2)
pipe.commit_timeline()
self.assertEqual(commit.call_count, 0)
self.assertEqual(commit.call_count, 1)
def test_prop_reset(self):
"""Checks the reset button resets the property."""
self.app = common.create_pitivi_mock()
self._register_alpha_widget(
("black_sens_adjustment", "GstAlpha::black-sensitivity", "GstAlpha::black-sensitivity::reset", "image1"))
wrapped_spin_button = self.element_settings_widget.properties[self.prop]
_, prop_value = self.alpha_effect.get_child_property(self.prop_name)
self.assertEqual(self.prop.default_value, prop_value)
self.assertEqual(self.prop.default_value, wrapped_spin_button.getWidgetValue())
# Set the property value to a different value than the default
wrapped_spin_button.setWidgetValue((1 + self.prop.default_value) % self.prop.maximum)
_, prop_value = self.alpha_effect.get_child_property(self.prop_name)
self.assertEqual(prop_value, (1 + self.prop.default_value) % self.prop.maximum)
# Reset the value of the property to default
prop_reset_button = \
list(self.element_settings_widget._GstElementSettingsWidget__widgets_by_reset_button.keys())[0]
prop_reset_button.clicked()
_, prop_value = self.alpha_effect.get_child_property(self.prop_name)
self.assertEqual(self.prop.default_value, prop_value)
self.assertEqual(self.prop.default_value, wrapped_spin_button.getWidgetValue())
def testLoad(self):
project = Project(uri="fake.xges", app=common.create_pitivi_mock())
self.assertEqual(project.name, "fake")
self.assertFalse(project._has_default_video_settings)
self.assertFalse(project._has_default_audio_settings)
def __init__(self):
pipeline.Pipeline.__init__(self, common.create_pitivi_mock())
self.state_calls = {}
self._timeline = mock.MagicMock()
def __init__(self):
pipeline.Pipeline.__init__(self, common.create_pitivi_mock())
self.state_calls = {}
self._timeline = mock.MagicMock()
def testLoad(self):
project = Project(uri="fake.xges", app=common.create_pitivi_mock())
self.assertEqual(project.name, "fake")
self.assertFalse(project._has_default_video_settings)
self.assertFalse(project._has_default_audio_settings)
