raoul/openlp
1
0
Fork 0
forked from openlp/openlp
Code Issues Pull Requests Projects Releases Wiki Activity

Start media

Browse Source
This commit is contained in:
Tim Bentley 2017-12-20 08:15:53 +00:00
parent 5764551e3e
commit 8f0779f600
5 changed files with 39 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
openlp/core/lib/__init__.py
View File

@ -25,7 +25,6 @@ OpenLP work.
"""
import html
import logging
import os
import re
import math

0
tests/functional/openlp_core/ui/lib/__init__.py
View File

20
tests/functional/openlp_core/ui/media/test_mediacontroller.py
View File

@ -54,10 +54,10 @@ class TestMediaController(TestCase, TestMixin):
media_controller._generate_extensions_lists()
# THEN: extensions list should have been copied from the player to the mediacontroller
self.assertListEqual(media_player.video_extensions_list, media_controller.video_extensions_list,
'Video extensions should be the same')
self.assertListEqual(media_player.audio_extensions_list, media_controller.audio_extensions_list,
'Audio extensions should be the same')
assert media_player.video_extensions_list == media_controller.video_extensions_list, \
'Video extensions should be the same'
assert media_player.audio_extensions_list == media_controller.audio_extensions_list, \
'Audio extensions should be the same'
def test_resize(self):
"""
@ -96,7 +96,7 @@ class TestMediaController(TestCase, TestMixin):
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return False
self.assertFalse(ret, '_check_file_type should return False when no mediaplayers are available.')
assert ret is False, '_check_file_type should return False when no mediaplayers are available.'
@patch('openlp.core.ui.media.mediacontroller.MediaController._get_used_players')
@patch('openlp.core.ui.media.mediacontroller.UiStrings')
@ -119,7 +119,7 @@ class TestMediaController(TestCase, TestMixin):
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return False
self.assertFalse(ret, '_check_file_type should return False when the processor for service_item is None.')
assert ret is False, '_check_file_type should return False when the processor for service_item is None.'
@patch('openlp.core.ui.media.mediacontroller.MediaController._get_used_players')
@patch('openlp.core.ui.media.mediacontroller.UiStrings')
@ -148,8 +148,8 @@ class TestMediaController(TestCase, TestMixin):
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return True
self.assertTrue(ret, '_check_file_type should return True when mediaplayers are available and '
'the service item has an automatic processor.')
assert ret is True, '_check_file_type should return True when mediaplayers are available and ' \
'the service item has an automatic processor.'
@patch('openlp.core.ui.media.mediacontroller.MediaController._get_used_players')
@patch('openlp.core.ui.media.mediacontroller.UiStrings')
@ -178,8 +178,8 @@ class TestMediaController(TestCase, TestMixin):
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return True
self.assertTrue(ret, '_check_file_type should return True when the players available are different'
'from the processor from the service item.')
assert ret is True, '_check_file_type should return True when the players available are different' \
'from the processor from the service item.'
def test_media_play_msg(self):
"""

56
tests/functional/openlp_core/ui/media/test_systemplayer.py
View File

@ -64,17 +64,17 @@ class TestSystemPlayer(TestCase):
player = SystemPlayer(self)
# THEN: The correct initial values should be set up
self.assertEqual('system', player.name)
self.assertEqual('System', player.original_name)
self.assertEqual('&System', player.display_name)
self.assertEqual(self, player.parent)
self.assertEqual(ADDITIONAL_EXT, player.additional_extensions)
assert 'system' == player.name
assert 'System' == player.original_name
assert '&System' == player.display_name
assert self == player.parent
assert ADDITIONAL_EXT == player.additional_extensions
MockQMediaPlayer.assert_called_once_with(None, QtMultimedia.QMediaPlayer.VideoSurface)
mocked_mimetypes.init.assert_called_once_with()
mocked_media_player.service.assert_called_once_with()
mocked_media_player.supportedMimeTypes.assert_called_once_with()
self.assertEqual(['*.aiff'], player.audio_extensions_list)
self.assertEqual(['*.afl', '*.asf'], player.video_extensions_list)
assert ['*.aiff'] == player.audio_extensions_list
assert ['*.afl', '*.asf'] == player.video_extensions_list
@patch('openlp.core.ui.media.systemplayer.QtMultimediaWidgets.QVideoWidget')
@patch('openlp.core.ui.media.systemplayer.QtMultimedia.QMediaPlayer')
@ -96,15 +96,15 @@ class TestSystemPlayer(TestCase):
# THEN: The player should have a display widget
MockQVideoWidget.assert_called_once_with(mocked_display)
self.assertEqual(mocked_video_widget, mocked_display.video_widget)
assert mocked_video_widget, mocked_display.video_widget is True
mocked_display.size.assert_called_once_with()
mocked_video_widget.resize.assert_called_once_with([1, 2, 3, 4])
MockQMediaPlayer.assert_called_with(mocked_display)
self.assertEqual(mocked_media_player, mocked_display.media_player)
assert mocked_media_player, mocked_display.media_player is True
mocked_media_player.setVideoOutput.assert_called_once_with(mocked_video_widget)
mocked_video_widget.raise_.assert_called_once_with()
mocked_video_widget.hide.assert_called_once_with()
self.assertTrue(player.has_own_widget)
assert player.has_own_widget is True
def test_disconnect_slots(self):
"""
@ -133,7 +133,7 @@ class TestSystemPlayer(TestCase):
result = player.check_available()
# THEN: it should be available
self.assertTrue(result)
assert result is True
def test_load_valid_media(self):
"""
@ -157,7 +157,7 @@ class TestSystemPlayer(TestCase):
mocked_display.media_player.setMedia.assert_called_once_with(
QtMultimedia.QMediaContent(QtCore.QUrl.fromLocalFile('/path/to/file')))
mocked_volume.assert_called_once_with(mocked_display, 1)
self.assertTrue(result)
assert result is True
def test_load_invalid_media(self):
"""
@ -178,7 +178,7 @@ class TestSystemPlayer(TestCase):
# THEN: stuff
mocked_display.controller.media_info.file_info.absoluteFilePath.assert_called_once_with()
mocked_check_media.assert_called_once_with('/path/to/file')
self.assertFalse(result)
assert result is False
def test_resize(self):
"""
@ -227,7 +227,7 @@ class TestSystemPlayer(TestCase):
mocked_display.media_player.durationChanged.connect.assert_called_once_with('function')
mocked_set_state.assert_called_once_with(MediaState.Playing, mocked_display)
mocked_display.video_widget.raise_.assert_called_once_with()
self.assertTrue(result)
assert result is True
@patch('openlp.core.ui.media.systemplayer.functools')
def test_play_is_preview(self, mocked_functools):
@ -258,7 +258,7 @@ class TestSystemPlayer(TestCase):
mocked_display.media_player.durationChanged.connect.assert_called_once_with('function')
mocked_set_state.assert_called_once_with(MediaState.Playing, mocked_display)
mocked_display.video_widget.raise_.assert_called_once_with()
self.assertTrue(result)
assert result is True
def test_pause_is_live(self):
"""
@ -419,14 +419,14 @@ class TestSystemPlayer(TestCase):
expected_position_calls = [call(), call()]
expected_block_signals_calls = [call(True), call(False)]
mocked_display.media_player.state.assert_called_once_with()
self.assertEqual(1, mocked_stop.call_count)
self.assertEqual(expected_stop_calls, mocked_stop.call_args_list)
self.assertEqual(2, mocked_display.media_player.position.call_count)
self.assertEqual(expected_position_calls, mocked_display.media_player.position.call_args_list)
assert 1 == mocked_stop.call_count
assert expected_stop_calls == mocked_stop.call_args_list
assert 2 == mocked_display.media_player.position.call_count
assert expected_position_calls == mocked_display.media_player.position.call_args_list
mocked_set_visible.assert_called_once_with(mocked_display, False)
mocked_display.controller.seek_slider.isSliderDown.assert_called_once_with()
self.assertEqual(expected_block_signals_calls,
mocked_display.controller.seek_slider.blockSignals.call_args_list)
assert expected_block_signals_calls == \
mocked_display.controller.seek_slider.blockSignals.call_args_list
mocked_display.controller.seek_slider.setSliderPosition.assert_called_once_with(2)
def test_get_media_display_css(self):
@ -440,7 +440,7 @@ class TestSystemPlayer(TestCase):
result = player.get_media_display_css()
# THEN: The css should be empty
self.assertEqual('', result)
assert '' == result
@patch('openlp.core.ui.media.systemplayer.QtMultimedia.QMediaPlayer')
def test_get_info(self, MockQMediaPlayer):
@ -459,7 +459,7 @@ class TestSystemPlayer(TestCase):
# THEN: The info should be correct
expected_info = 'This media player uses your operating system to provide media capabilities.<br/> ' \
'<strong>Audio</strong><br/>[]<br/><strong>Video</strong><br/>[]<br/>'
self.assertEqual(expected_info, result)
assert expected_info == result
@patch('openlp.core.ui.media.systemplayer.CheckMediaWorker')
@patch('openlp.core.ui.media.systemplayer.QtCore.QThread')
@ -493,9 +493,9 @@ class TestSystemPlayer(TestCase):
mocked_check_media_worker.finished.connect.assert_called_once_with('quit')
mocked_thread.started.connect.assert_called_once_with('play')
mocked_thread.start.assert_called_once_with()
self.assertEqual(2, mocked_thread.isRunning.call_count)
assert 2 == mocked_thread.isRunning.call_count
mocked_application.processEvents.assert_called_once_with()
self.assertTrue(result)
assert result is True
class TestCheckMediaWorker(TestCase):
@ -513,7 +513,7 @@ class TestCheckMediaWorker(TestCase):
worker = CheckMediaWorker(path)
# THEN: The correct values should be set up
self.assertIsNotNone(worker)
assert worker is not None
def test_signals_media(self):
"""
@ -530,7 +530,7 @@ class TestCheckMediaWorker(TestCase):
# THEN: The worker should exit and the result should be True
mocked_stop.assert_called_once_with()
mocked_finished.emit.assert_called_once_with()
self.assertTrue(worker.result)
assert worker.result is True
def test_signals_error(self):
"""
@ -547,4 +547,4 @@ class TestCheckMediaWorker(TestCase):
# THEN: The worker should exit and the result should be True
mocked_stop.assert_called_once_with()
mocked_finished.emit.assert_called_once_with()
self.assertFalse(worker.result)
assert worker.result is False

2
tests/functional/openlp_core/widgets/test_edits.py
View File

@ -27,9 +27,9 @@ from unittest import TestCase
from unittest.mock import MagicMock, PropertyMock, patch
from openlp.core.common.path import Path
from openlp.core.widgets.edits import PathEdit
from openlp.core.widgets.enums import PathEditType
from openlp.core.widgets.dialogs import FileDialog
from openlp.core.widgets.edits import PathEdit
class TestPathEdit(TestCase):