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

more ui bits

This commit is contained in:
Tim Bentley 2017-12-20 20:38:43 +00:00
parent e055ed65a3
commit ffb23a4575
4 changed files with 202 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
tests/functional/openlp_core/ui/test_maindisplay.py
View File

@ -83,7 +83,7 @@ class TestMainDisplay(TestCase, TestMixin):
main_display = MainDisplay(display)
# THEN: The controller should be a live controller.
self.assertEqual(main_display.is_live, True, 'The main display should be a live controller')
assert main_display.is_live is True, 'The main display should be a live controller'
def test_set_transparency_enabled(self):
"""
@ -97,12 +97,12 @@ class TestMainDisplay(TestCase, TestMixin):
main_display.set_transparency(True)
# THEN: The transparent stylesheet should be used
self.assertEqual(TRANSPARENT_STYLESHEET, main_display.styleSheet(),
'The MainDisplay should use the transparent stylesheet')
self.assertFalse(main_display.autoFillBackground(),
'The MainDisplay should not have autoFillBackground set')
self.assertTrue(main_display.testAttribute(QtCore.Qt.WA_TranslucentBackground),
'The MainDisplay should have a translucent background')
assert TRANSPARENT_STYLESHEET == main_display.styleSheet(), \
'The MainDisplay should use the transparent stylesheet'
assert main_display.autoFillBackground() is False, \
'The MainDisplay should not have autoFillBackground set'
assert main_display.testAttribute(QtCore.Qt.WA_TranslucentBackground) is True, \
'The MainDisplay should have a translucent background'
def test_set_transparency_disabled(self):
"""
@ -116,10 +116,10 @@ class TestMainDisplay(TestCase, TestMixin):
main_display.set_transparency(False)
# THEN: The opaque stylesheet should be used
self.assertEqual(OPAQUE_STYLESHEET, main_display.styleSheet(),
'The MainDisplay should use the opaque stylesheet')
self.assertFalse(main_display.testAttribute(QtCore.Qt.WA_TranslucentBackground),
'The MainDisplay should not have a translucent background')
assert OPAQUE_STYLESHEET == main_display.styleSheet(), \
'The MainDisplay should use the opaque stylesheet'
assert main_display.testAttribute(QtCore.Qt.WA_TranslucentBackground) is False, \
'The MainDisplay should not have a translucent background'
def test_css_changed(self):
"""
@ -156,9 +156,9 @@ class TestMainDisplay(TestCase, TestMixin):
main_display = MainDisplay(display)
# THEN: The window flags should be the same as those needed on Mac OS X.
self.assertEqual(QtCore.Qt.Window | QtCore.Qt.FramelessWindowHint | QtCore.Qt.NoDropShadowWindowHint,
main_display.windowFlags(),
'The window flags should be Qt.Window, Qt.FramelessWindowHint, and Qt.NoDropShadowWindowHint.')
assert QtCore.Qt.Window | QtCore.Qt.FramelessWindowHint | QtCore.Qt.NoDropShadowWindowHint == \
main_display.windowFlags(), \
'The window flags should be Qt.Window, Qt.FramelessWindowHint, and Qt.NoDropShadowWindowHint.'
@skipUnless(is_macosx(), 'Can only run test on Mac OS X due to pyobjc dependency.')
def test_macosx_display(self):
@ -181,10 +181,10 @@ class TestMainDisplay(TestCase, TestMixin):
pyobjc_nsview = objc_object(cobject=nsview_pointer)
# THEN: The window level and collection behavior should be the same as those needed for Mac OS X.
self.assertEqual(pyobjc_nsview.window().level(), NSMainMenuWindowLevel + 2,
'Window level should be NSMainMenuWindowLevel + 2')
self.assertEqual(pyobjc_nsview.window().collectionBehavior(), NSWindowCollectionBehaviorManaged,
'Window collection behavior should be NSWindowCollectionBehaviorManaged')
assert pyobjc_nsview.window().level() == NSMainMenuWindowLevel + 2, \
'Window level should be NSMainMenuWindowLevel + 2'
assert pyobjc_nsview.window().collectionBehavior() == NSWindowCollectionBehaviorManaged, \
'Window collection behavior should be NSWindowCollectionBehaviorManaged'
@patch('openlp.core.ui.maindisplay.Settings')
def test_show_display_startup_logo(self, MockedSettings):
@ -250,9 +250,9 @@ class TestMainDisplay(TestCase, TestMixin):
main_display.build_html(service_item)
# THEN: the following should had not been called
self.assertEquals(main_display.web_view.setHtml.call_count, 1, 'setHTML should be called once')
self.assertEquals(main_display.media_controller.video.call_count, 0,
'Media Controller video should not have been called')
assert main_display.web_view.setHtml.call_count == 1, 'setHTML should be called once'
assert main_display.media_controller.video.call_count == 0, \
'Media Controller video should not have been called'
@patch('openlp.core.ui.maindisplay.Settings')
@patch('openlp.core.ui.maindisplay.build_html')
@ -282,9 +282,9 @@ class TestMainDisplay(TestCase, TestMixin):
main_display.build_html(service_item)
# THEN: the following should had not been called
self.assertEquals(main_display.web_view.setHtml.call_count, 1, 'setHTML should be called once')
self.assertEquals(main_display.media_controller.video.call_count, 1,
'Media Controller video should have been called once')
assert main_display.web_view.setHtml.call_count == 1, 'setHTML should be called once'
assert main_display.media_controller.video.call_count == 1, \
'Media Controller video should have been called once'
def test_calling_next_item_in_playlist():

8
tests/functional/openlp_core/ui/test_mainwindow.py
View File

@ -130,8 +130,8 @@ class TestMainWindow(TestCase, TestMixin):
self.main_window.set_service_modified(True, 'test.osz')
# THEN the main window's title should be set to the
self.assertEqual(self.main_window.windowTitle(), '%s - %s*' % (UiStrings().OpenLP, 'test.osz'),
'The main window\'s title should be set to "<the contents of UiStrings().OpenLP> - test.osz*"')
assert self.main_window.windowTitle(), '%s - %s*' % (UiStrings().OpenLP, 'test.osz') == \
'The main window\'s title should be set to "<the contents of UiStrings().OpenLP> - test.osz*"'
def test_set_service_unmodified(self):
"""
@ -143,8 +143,8 @@ class TestMainWindow(TestCase, TestMixin):
self.main_window.set_service_modified(False, 'test.osz')
# THEN the main window's title should be set to the
self.assertEqual(self.main_window.windowTitle(), '%s - %s' % (UiStrings().OpenLP, 'test.osz'),
'The main window\'s title should be set to "<the contents of UiStrings().OpenLP> - test.osz"')
assert self.main_window.windowTitle(), '%s - %s' % (UiStrings().OpenLP, 'test.osz') == \
'The main window\'s title should be set to "<the contents of UiStrings().OpenLP> - test.osz"'
def test_mainwindow_configuration(self):
"""

44
tests/functional/openlp_core/ui/test_media.py
View File

@ -52,8 +52,8 @@ class TestMedia(TestCase, TestMixin):
used_players, overridden_player = get_media_players()
# THEN: the used_players should be an empty list, and the overridden player should be an empty string
self.assertEqual([], used_players, 'Used players should be an empty list')
self.assertEqual('', overridden_player, 'Overridden player should be an empty string')
assert [] == used_players, 'Used players should be an empty list'
assert '' == overridden_player, 'Overridden player should be an empty string'
def test_get_media_players_no_players(self):
"""
@ -73,8 +73,8 @@ class TestMedia(TestCase, TestMixin):
used_players, overridden_player = get_media_players()
# THEN: the used_players should be an empty list, and the overridden player should be an empty string
self.assertEqual([], used_players, 'Used players should be an empty list')
self.assertEqual('auto', overridden_player, 'Overridden player should be "auto"')
assert [] == used_players, 'Used players should be an empty list'
assert 'auto' == overridden_player, 'Overridden player should be "auto"'
def test_get_media_players_with_valid_list(self):
"""
@ -94,8 +94,8 @@ class TestMedia(TestCase, TestMixin):
used_players, overridden_player = get_media_players()
# THEN: the used_players should be an empty list, and the overridden player should be an empty string
self.assertEqual(['vlc', 'webkit', 'system'], used_players, 'Used players should be correct')
self.assertEqual('', overridden_player, 'Overridden player should be an empty string')
assert ['vlc', 'webkit', 'system'] == used_players, 'Used players should be correct'
assert '' == overridden_player, 'Overridden player should be an empty string'
def test_get_media_players_with_overridden_player(self):
"""
@ -115,8 +115,8 @@ class TestMedia(TestCase, TestMixin):
used_players, overridden_player = get_media_players()
# THEN: the used_players should be an empty list, and the overridden player should be an empty string
self.assertEqual(['vlc', 'webkit', 'system'], used_players, 'Used players should be correct')
self.assertEqual('vlc,webkit,system', overridden_player, 'Overridden player should be a string of players')
assert ['vlc', 'webkit', 'system'] == used_players, 'Used players should be correct'
assert 'vlc,webkit,system' == overridden_player, 'Overridden player should be a string of players'
def test_parse_optical_path_linux(self):
"""
@ -138,13 +138,13 @@ class TestMedia(TestCase, TestMixin):
(device_path, title_track, audio_track, subtitle_track, start, end, name) = parse_optical_path(path)
# THEN: The return values should match the original values
self.assertEqual(org_title_track, title_track, 'Returned title_track should match the original')
self.assertEqual(org_audio_track, audio_track, 'Returned audio_track should match the original')
self.assertEqual(org_subtitle_track, subtitle_track, 'Returned subtitle_track should match the original')
self.assertEqual(org_start, start, 'Returned start should match the original')
self.assertEqual(org_end, end, 'Returned end should match the original')
self.assertEqual(org_name, name, 'Returned end should match the original')
self.assertEqual(org_device_path, device_path, 'Returned device_path should match the original')
assert org_title_track == title_track, 'Returned title_track should match the original'
assert org_audio_track == audio_track, 'Returned audio_track should match the original'
assert org_subtitle_track == subtitle_track, 'Returned subtitle_track should match the original'
assert org_start == start, 'Returned start should match the original'
assert org_end == end, 'Returned end should match the original'
assert org_name == name, 'Returned end should match the original'
assert org_device_path == device_path, 'Returned device_path should match the original'
def test_parse_optical_path_win(self):
"""
@ -166,10 +166,10 @@ class TestMedia(TestCase, TestMixin):
(device_path, title_track, audio_track, subtitle_track, start, end, name) = parse_optical_path(path)
# THEN: The return values should match the original values
self.assertEqual(org_title_track, title_track, 'Returned title_track should match the original')
self.assertEqual(org_audio_track, audio_track, 'Returned audio_track should match the original')
self.assertEqual(org_subtitle_track, subtitle_track, 'Returned subtitle_track should match the original')
self.assertEqual(org_start, start, 'Returned start should match the original')
self.assertEqual(org_end, end, 'Returned end should match the original')
self.assertEqual(org_name, name, 'Returned end should match the original')
self.assertEqual(org_device_path, device_path, 'Returned device_path should match the original')
assert org_title_track == title_track, 'Returned title_track should match the original'
assert org_audio_track == audio_track, 'Returned audio_track should match the original'
assert org_subtitle_track == subtitle_track, 'Returned subtitle_track should match the original'
assert org_start == start, 'Returned start should match the original'
assert org_end == end, 'Returned end should match the original'
assert org_name == name, 'Returned end should match the original'
assert org_device_path == device_path, 'Returned device_path should match the original'

305
tests/functional/openlp_core/ui/test_servicemanager.py
View File

@ -54,7 +54,7 @@ class TestServiceManager(TestCase):
ServiceManager(None)
# WHEN: the default service manager is built.
# THEN: The the controller should be registered in the registry.
self.assertNotEqual(Registry().get('service_manager'), None, 'The base service manager should be registered')
assert Registry().get('service_manager') is not None, 'The base service manager should be registered'
def test_create_basic_service(self):
"""
@ -67,9 +67,9 @@ class TestServiceManager(TestCase):
service_manager.service_theme = 'test_theme'
service = service_manager.create_basic_service()[0]
# THEN: The controller should be registered in the registry.
self.assertNotEqual(service, None, 'The base service should be created')
self.assertEqual(service['openlp_core']['service-theme'], 'test_theme', 'The test theme should be saved')
self.assertEqual(service['openlp_core']['lite-service'], False, 'The lite service should be saved')
assert service is not None, 'The base service should be created'
assert service['openlp_core']['service-theme'] == 'test_theme', 'The test theme should be saved'
assert service['openlp_core']['lite-service'] is False, 'The lite service should be saved'
def test_supported_suffixes(self):
"""
@ -81,9 +81,9 @@ class TestServiceManager(TestCase):
service_manager.supported_suffixes('txt')
service_manager.supported_suffixes(['pptx', 'ppt'])
# THEN: The suffixes should be available to test.
self.assertEqual('txt' in service_manager.suffixes, True, 'The suffix txt should be in the list')
self.assertEqual('ppt' in service_manager.suffixes, True, 'The suffix ppt should be in the list')
self.assertEqual('pptx' in service_manager.suffixes, True, 'The suffix pptx should be in the list')
assert 'txt' in service_manager.suffixes, 'The suffix txt should be in the list'
assert 'ppt' in service_manager.suffixes, 'The suffix ppt should be in the list'
assert 'pptx' in service_manager.suffixes, 'The suffix pptx should be in the list'
def test_build_context_menu(self):
"""
@ -114,20 +114,20 @@ class TestServiceManager(TestCase):
# WHEN I define a context menu
service_manager.context_menu(1)
# THEN the following calls should have occurred.
self.assertEqual(service_manager.edit_action.setVisible.call_count, 1, 'Should have been called once')
self.assertEqual(service_manager.rename_action.setVisible.call_count, 1, 'Should have been called once')
self.assertEqual(service_manager.create_custom_action.setVisible.call_count, 1, 'Should have been called once')
self.assertEqual(service_manager.maintain_action.setVisible.call_count, 1, 'Should have been called once')
self.assertEqual(service_manager.notes_action.setVisible.call_count, 1, 'Should have been called once')
self.assertEqual(service_manager.time_action.setVisible.call_count, 1, 'Should have been called once')
self.assertEqual(service_manager.auto_start_action.setVisible.call_count, 1, 'Should have been called once')
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 1,
'Should have been called once')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
'Should have been called once')
assert service_manager.edit_action.setVisible.call_count == 1, 'Should have been called once'
assert service_manager.rename_action.setVisible.call_count == 1, 'Should have been called once'
assert service_manager.create_custom_action.setVisible.call_count == 1, 'Should have been called once'
assert service_manager.maintain_action.setVisible.call_count == 1, 'Should have been called once'
assert service_manager.notes_action.setVisible.call_count == 1, 'Should have been called once'
assert service_manager.time_action.setVisible.call_count == 1, 'Should have been called once'
assert service_manager.auto_start_action.setVisible.call_count == 1, 'Should have been called once'
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
'Should have been called once'
assert service_manager.auto_play_slides_once.setChecked.call_count == 0, 'Should not be called'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 0, 'Should not be called'
assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
'Should have been called once'
def test_build_song_context_menu(self):
"""
@ -169,29 +169,29 @@ class TestServiceManager(TestCase):
# WHEN I define a context menu
service_manager.context_menu(1)
# THEN the following calls should have occurred.
self.assertEqual(service_manager.edit_action.setVisible.call_count, 2, 'Should have be called twice')
self.assertEqual(service_manager.rename_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.create_custom_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.maintain_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.notes_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.time_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_start_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 2,
'Should have be called twice')
assert service_manager.edit_action.setVisible.call_count == 2, 'Should have be called twice'
assert service_manager.rename_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.create_custom_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.maintain_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.notes_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.time_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_start_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
assert service_manager.auto_play_slides_once.setChecked.call_count == 0, 'Should not be called'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 0, 'Should not be called'
assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
assert service_manager.theme_menu.menuAction().setVisible.call_count == 2, \
'Should have be called twice'
# THEN we add a 2nd display frame
service_item._display_frames.append(MagicMock())
service_manager.context_menu(1)
# THEN the following additional calls should have occurred.
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 2,
'Should have be called twice')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 1, 'Should have be called once')
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 2, \
'Should have be called twice'
assert service_manager.auto_play_slides_once.setChecked.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 1, 'Should have be called once'
assert service_manager.timed_slide_interval.setChecked.call_count == 1, 'Should have be called once'
def test_build_bible_context_menu(self):
"""
@ -233,29 +233,29 @@ class TestServiceManager(TestCase):
# WHEN I define a context menu
service_manager.context_menu(1)
# THEN the following calls should have occurred.
self.assertEqual(service_manager.edit_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.rename_action.setVisible.call_count, 2, 'Should have be called twice')
self.assertEqual(service_manager.create_custom_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.maintain_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.notes_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.time_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_start_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 2,
'Should have be called twice')
assert service_manager.edit_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.rename_action.setVisible.call_count == 2, 'Should have be called twice'
assert service_manager.create_custom_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.maintain_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.notes_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.time_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_start_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
assert service_manager.auto_play_slides_once.setChecked.call_count == 0, 'Should not be called'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 0, 'Should not be called'
assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
assert service_manager.theme_menu.menuAction().setVisible.call_count == 2, \
'Should have be called twice'
# THEN we add a 2nd display frame
service_item._display_frames.append(MagicMock())
service_manager.context_menu(1)
# THEN the following additional calls should have occurred.
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 2,
'Should have be called twice')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 1, 'Should have be called once')
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 2, \
'Should have be called twice'
assert service_manager.auto_play_slides_once.setChecked.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 1, 'Should have be called once'
assert service_manager.timed_slide_interval.setChecked.call_count == 1, 'Should have be called once'
def test_build_custom_context_menu(self):
"""
@ -298,29 +298,29 @@ class TestServiceManager(TestCase):
# WHEN I define a context menu
service_manager.context_menu(1)
# THEN the following calls should have occurred.
self.assertEqual(service_manager.edit_action.setVisible.call_count, 2, 'Should have be called twice')
self.assertEqual(service_manager.rename_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.create_custom_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.maintain_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.notes_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.time_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_start_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 2,
'Should have be called twice')
assert service_manager.edit_action.setVisible.call_count == 2, 'Should have be called twice'
assert service_manager.rename_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.create_custom_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.maintain_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.notes_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.time_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_start_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
assert service_manager.auto_play_slides_once.setChecked.call_count == 0, 'Should not be called'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 0, 'Should not be called'
assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
assert service_manager.theme_menu.menuAction().setVisible.call_count == 2, \
'Should have be called twice'
# THEN we add a 2nd display frame
service_item._display_frames.append(MagicMock())
service_manager.context_menu(1)
# THEN the following additional calls should have occurred.
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 2,
'Should have be called twice')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 1, 'Should have be called once')
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 2, \
'Should have be called twice'
assert service_manager.auto_play_slides_once.setChecked.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 1, 'Should have be called once'
assert service_manager.timed_slide_interval.setChecked.call_count == 1, 'Should have be called once'
def test_build_image_context_menu(self):
"""
@ -361,29 +361,29 @@ class TestServiceManager(TestCase):
# WHEN I define a context menu
service_manager.context_menu(1)
# THEN the following calls should have occurred.
self.assertEqual(service_manager.edit_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.rename_action.setVisible.call_count, 2, 'Should have be called twice')
self.assertEqual(service_manager.create_custom_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.maintain_action.setVisible.call_count, 2, 'Should have be called twice')
self.assertEqual(service_manager.notes_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.time_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_start_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
assert service_manager.edit_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.rename_action.setVisible.call_count == 2, 'Should have be called twice'
assert service_manager.create_custom_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.maintain_action.setVisible.call_count == 2, 'Should have be called twice'
assert service_manager.notes_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.time_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_start_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
assert service_manager.auto_play_slides_once.setChecked.call_count == 0, 'Should not be called'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 0, 'Should not be called'
assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
# THEN we add a 2nd display frame and regenerate the menu.
service_item._raw_frames.append(MagicMock())
service_manager.context_menu(1)
# THEN the following additional calls should have occurred.
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 2,
'Should have be called twice')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 1, 'Should have be called once')
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 2, \
'Should have be called twice'
assert service_manager.auto_play_slides_once.setChecked.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 1, 'Should have be called once'
assert service_manager.timed_slide_interval.setChecked.call_count == 1, 'Should have be called once'
def test_build_media_context_menu(self):
"""
@ -422,25 +422,25 @@ class TestServiceManager(TestCase):
# WHEN I define a context menu
service_manager.context_menu(1)
# THEN the following calls should have occurred.
self.assertEqual(service_manager.edit_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.rename_action.setVisible.call_count, 2, 'Should have be called twice')
self.assertEqual(service_manager.create_custom_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.maintain_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.notes_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.time_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_start_action.setVisible.call_count, 2, 'Should have be called twice')
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
assert service_manager.edit_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.rename_action.setVisible.call_count == 2, 'Should have be called twice'
assert service_manager.create_custom_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.maintain_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.notes_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.time_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_start_action.setVisible.call_count == 2, 'Should have be called twice'
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
assert service_manager.auto_play_slides_once.setChecked.call_count == 0, 'Should not be called'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 0, 'Should not be called'
assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
# THEN I change the length of the media and regenerate the menu.
service_item.set_media_length(5)
service_manager.context_menu(1)
# THEN the following additional calls should have occurred.
self.assertEqual(service_manager.time_action.setVisible.call_count, 3, 'Should have be called three times')
assert service_manager.time_action.setVisible.call_count == 3, 'Should have be called three times'
def test_build_presentation_pdf_context_menu(self):
"""
@ -480,20 +480,20 @@ class TestServiceManager(TestCase):
# WHEN I define a context menu
service_manager.context_menu(1)
# THEN the following calls should have occurred.
self.assertEqual(service_manager.edit_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.rename_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.create_custom_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.maintain_action.setVisible.call_count, 2, 'Should have be called twice')
self.assertEqual(service_manager.notes_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.time_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_start_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
assert service_manager.edit_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.rename_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.create_custom_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.maintain_action.setVisible.call_count == 2, 'Should have be called twice'
assert service_manager.notes_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.time_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_start_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
assert service_manager.auto_play_slides_once.setChecked.call_count == 0, 'Should not be called'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 0, 'Should not be called'
assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
def test_build_presentation_non_pdf_context_menu(self):
"""
@ -530,20 +530,20 @@ class TestServiceManager(TestCase):
# WHEN I define a context menu
service_manager.context_menu(1)
# THEN the following calls should have occurred.
self.assertEqual(service_manager.edit_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.rename_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.create_custom_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.maintain_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.notes_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.time_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_start_action.setVisible.call_count, 1, 'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.auto_play_slides_loop.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.timed_slide_interval.setChecked.call_count, 0, 'Should not be called')
self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
'Should have be called once')
assert service_manager.edit_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.rename_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.create_custom_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.maintain_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.notes_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.time_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_start_action.setVisible.call_count == 1, 'Should have be called once'
assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
assert service_manager.auto_play_slides_once.setChecked.call_count == 0, 'Should not be called'
assert service_manager.auto_play_slides_loop.setChecked.call_count == 0, 'Should not be called'
assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
'Should have be called once'
@patch('openlp.core.ui.servicemanager.Settings')
@patch('PyQt5.QtCore.QTimer.singleShot')
@ -576,7 +576,7 @@ class TestServiceManager(TestCase):
# WHEN: on_single_click_preview() is called
service_manager.on_single_click_preview()
# THEN: timer should not be started
self.assertEqual(mocked_singleShot.call_count, 0, 'Should not be called')
assert mocked_singleShot.call_count == 0, 'Should not be called'
@patch('openlp.core.ui.servicemanager.Settings')
@patch('PyQt5.QtCore.QTimer.singleShot')
@ -595,7 +595,7 @@ class TestServiceManager(TestCase):
service_manager.on_single_click_preview()
# THEN: timer should not be started
mocked_make_live.assert_called_with()
self.assertEqual(mocked_singleShot.call_count, 0, 'Should not be called')
assert mocked_singleShot.call_count == 0, 'Should not be called'
@patch('openlp.core.ui.servicemanager.ServiceManager.make_preview')
def test_single_click_timeout_single(self, mocked_make_preview):
@ -607,8 +607,7 @@ class TestServiceManager(TestCase):
# WHEN: on_single_click_preview() is called
service_manager.on_single_click_preview_timeout()
# THEN: make_preview() should have been called
self.assertEqual(mocked_make_preview.call_count, 1,
'ServiceManager.make_preview() should have been called once')
assert mocked_make_preview.call_count == 1, 'ServiceManager.make_preview() should have been called once'
@patch('openlp.core.ui.servicemanager.ServiceManager.make_preview')
@patch('openlp.core.ui.servicemanager.ServiceManager.make_live')
@ -622,7 +621,7 @@ class TestServiceManager(TestCase):
service_manager.on_double_click_live()
service_manager.on_single_click_preview_timeout()
# THEN: make_preview() should not have been called
self.assertEqual(mocked_make_preview.call_count, 0, 'ServiceManager.make_preview() should not be called')
assert mocked_make_preview.call_count == 0, 'ServiceManager.make_preview() should not be called'
@patch('openlp.core.ui.servicemanager.shutil.copy')
@patch('openlp.core.ui.servicemanager.zipfile')
@ -650,7 +649,7 @@ class TestServiceManager(TestCase):
result = service_manager.save_file()
# THEN: The "save_as" method is called to save the service
self.assertTrue(result)
assert result is True
mocked_save_file_as.assert_called_with()
@patch('openlp.core.ui.servicemanager.shutil.copy')
@ -678,7 +677,7 @@ class TestServiceManager(TestCase):
result = service_manager.save_local_file()
# THEN: The "save_as" method is called to save the service
self.assertTrue(result)
assert result is True
mocked_save_file_as.assert_called_with()
@patch('openlp.core.ui.servicemanager.ServiceManager.regenerate_service_items')
@ -699,8 +698,8 @@ class TestServiceManager(TestCase):
service_manager.theme_change()
# THEN: The the theme toolbar should not be visible
self.assertFalse(service_manager.toolbar.actions['theme_combo_box'].isVisible(),
'The visibility should be False')
assert service_manager.toolbar.actions['theme_combo_box'].isVisible() is False, \
'The visibility should be False'
@patch('openlp.core.ui.servicemanager.ServiceManager.regenerate_service_items')
def test_theme_change_service(self, mocked_regenerate_service_items):
@ -720,8 +719,8 @@ class TestServiceManager(TestCase):
service_manager.theme_change()
# THEN: The the theme toolbar should be visible
self.assertTrue(service_manager.toolbar.actions['theme_combo_box'].isVisible(),
'The visibility should be True')
assert service_manager.toolbar.actions['theme_combo_box'].isVisible() is True, \
'The visibility should be True'
@patch('openlp.core.ui.servicemanager.ServiceManager.regenerate_service_items')
def test_theme_change_song(self, mocked_regenerate_service_items):
@ -741,5 +740,5 @@ class TestServiceManager(TestCase):
service_manager.theme_change()
# THEN: The the theme toolbar should be visible
self.assertTrue(service_manager.toolbar.actions['theme_combo_box'].isVisible(),
'The visibility should be True')
assert service_manager.toolbar.actions['theme_combo_box'].isVisible() is True, \
'The visibility should be True'