more ui bits

tests/functional/openlp_core/ui/test_maindisplay.py

@@ -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(),
+        assert TRANSPARENT_STYLESHEET == main_display.styleSheet(), \
-                         'The MainDisplay should use the transparent stylesheet')
+            'The MainDisplay should use the transparent stylesheet'
-        self.assertFalse(main_display.autoFillBackground(),
+        assert main_display.autoFillBackground() is False, \
-                         'The MainDisplay should not have autoFillBackground set')
+            'The MainDisplay should not have autoFillBackground set'
-        self.assertTrue(main_display.testAttribute(QtCore.Qt.WA_TranslucentBackground),
+        assert main_display.testAttribute(QtCore.Qt.WA_TranslucentBackground) is True, \
-                        'The MainDisplay should have a translucent background')
+            '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(),
+        assert OPAQUE_STYLESHEET == main_display.styleSheet(), \
-                         'The MainDisplay should use the opaque stylesheet')
+            'The MainDisplay should use the opaque stylesheet'
-        self.assertFalse(main_display.testAttribute(QtCore.Qt.WA_TranslucentBackground),
+        assert main_display.testAttribute(QtCore.Qt.WA_TranslucentBackground) is False, \
-                         'The MainDisplay should not have a translucent background')
+            '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,
+        assert QtCore.Qt.Window | QtCore.Qt.FramelessWindowHint | QtCore.Qt.NoDropShadowWindowHint == \
-                         main_display.windowFlags(),
+            main_display.windowFlags(), \
-                         'The window flags should be Qt.Window, Qt.FramelessWindowHint, and Qt.NoDropShadowWindowHint.')
+            '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,
+        assert pyobjc_nsview.window().level() == NSMainMenuWindowLevel + 2, \
-                         'Window level should be NSMainMenuWindowLevel + 2')
+            'Window level should be NSMainMenuWindowLevel + 2'
-        self.assertEqual(pyobjc_nsview.window().collectionBehavior(), NSWindowCollectionBehaviorManaged,
+        assert pyobjc_nsview.window().collectionBehavior() == NSWindowCollectionBehaviorManaged, \
-                         'Window collection behavior should be 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')
+        assert main_display.web_view.setHtml.call_count == 1, 'setHTML should be called once'
-        self.assertEquals(main_display.media_controller.video.call_count, 0,
+        assert main_display.media_controller.video.call_count == 0, \
-                          'Media Controller video should not have been called')
+            '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')
+        assert main_display.web_view.setHtml.call_count == 1, 'setHTML should be called once'
-        self.assertEquals(main_display.media_controller.video.call_count, 1,
+        assert main_display.media_controller.video.call_count == 1, \
-                          'Media Controller video should have been called once')
+            'Media Controller video should have been called once'
 
 
 def test_calling_next_item_in_playlist():

tests/functional/openlp_core/ui/test_mainwindow.py

@@ -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'),
+        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*"')
+            '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'),
+        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"')
+            'The main window\'s title should be set to "<the contents of UiStrings().OpenLP> - test.osz"'
 
     def test_mainwindow_configuration(self):
         """

tests/functional/openlp_core/ui/test_media.py

@@ -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')
+            assert [] == used_players, 'Used players should be an empty list'
-            self.assertEqual('', overridden_player, 'Overridden player should be an empty string')
+            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')
+            assert [] == used_players, 'Used players should be an empty list'
-            self.assertEqual('auto', overridden_player, 'Overridden player should be "auto"')
+            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')
+            assert ['vlc', 'webkit', 'system'] == used_players, 'Used players should be correct'
-            self.assertEqual('', overridden_player, 'Overridden player should be an empty string')
+            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')
+            assert ['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' == 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')
+        assert 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')
+        assert 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')
+        assert org_subtitle_track == subtitle_track, 'Returned subtitle_track should match the original'
-        self.assertEqual(org_start, start, 'Returned start should match the original')
+        assert org_start == start, 'Returned start should match the original'
-        self.assertEqual(org_end, end, 'Returned end should match the original')
+        assert org_end == end, 'Returned end should match the original'
-        self.assertEqual(org_name, name, 'Returned end should match the original')
+        assert 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_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')
+        assert 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')
+        assert 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')
+        assert org_subtitle_track == subtitle_track, 'Returned subtitle_track should match the original'
-        self.assertEqual(org_start, start, 'Returned start should match the original')
+        assert org_start == start, 'Returned start should match the original'
-        self.assertEqual(org_end, end, 'Returned end should match the original')
+        assert org_end == end, 'Returned end should match the original'
-        self.assertEqual(org_name, name, 'Returned end should match the original')
+        assert 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_device_path == device_path, 'Returned device_path should match the original'

tests/functional/openlp_core/ui/test_servicemanager.py

@@ -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')
+        assert service is not None, 'The base service should be created'
-        self.assertEqual(service['openlp_core']['service-theme'], 'test_theme', 'The test theme should be saved')
+        assert 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['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')
+        assert 'txt' in service_manager.suffixes, 'The suffix txt should be in the list'
-        self.assertEqual('ppt' in service_manager.suffixes, True, 'The suffix ppt should be in the list')
+        assert 'ppt' in service_manager.suffixes, '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 '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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have been called once')
+            'Should have been called once'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
+        assert 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')
+        assert 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')
+        assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
-        self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
+        assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have been called once')
+            '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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            'Should have be called once'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
+        assert 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')
+        assert 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')
+        assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
-        self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 2,
+        assert service_manager.theme_menu.menuAction().setVisible.call_count == 2, \
-                         'Should have be called twice')
+            '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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 2, \
-                         'Should have be called twice')
+            'Should have be called twice'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 1, 'Should have be called once')
+        assert 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')
+        assert 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.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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            'Should have be called once'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
+        assert 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')
+        assert 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')
+        assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
-        self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 2,
+        assert service_manager.theme_menu.menuAction().setVisible.call_count == 2, \
-                         'Should have be called twice')
+            '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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 2, \
-                         'Should have be called twice')
+            'Should have be called twice'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 1, 'Should have be called once')
+        assert 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')
+        assert 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.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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            'Should have be called once'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
+        assert 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')
+        assert 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')
+        assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
-        self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 2,
+        assert service_manager.theme_menu.menuAction().setVisible.call_count == 2, \
-                         'Should have be called twice')
+            '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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 2, \
-                         'Should have be called twice')
+            'Should have be called twice'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 1, 'Should have be called once')
+        assert 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')
+        assert 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.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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            'Should have be called once'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
+        assert 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')
+        assert 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')
+        assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
-        self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
+        assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            '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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 2, \
-                         'Should have be called twice')
+            'Should have be called twice'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 1, 'Should have be called once')
+        assert 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')
+        assert 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.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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            'Should have be called once'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
+        assert 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')
+        assert 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')
+        assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
-        self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
+        assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            '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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            'Should have be called once'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
+        assert 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')
+        assert 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')
+        assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
-        self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
+        assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            '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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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')
+        assert 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,
+        assert service_manager.auto_play_slides_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            'Should have be called once'
-        self.assertEqual(service_manager.auto_play_slides_once.setChecked.call_count, 0, 'Should not be called')
+        assert 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')
+        assert 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')
+        assert service_manager.timed_slide_interval.setChecked.call_count == 0, 'Should not be called'
-        self.assertEqual(service_manager.theme_menu.menuAction().setVisible.call_count, 1,
+        assert service_manager.theme_menu.menuAction().setVisible.call_count == 1, \
-                         'Should have be called once')
+            '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,
+        assert mocked_make_preview.call_count == 1, 'ServiceManager.make_preview() should have been called once'
-                         '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(),
+        assert service_manager.toolbar.actions['theme_combo_box'].isVisible() is False, \
-                         'The visibility should be 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(),
+        assert service_manager.toolbar.actions['theme_combo_box'].isVisible() is True, \
-                        'The visibility should be 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(),
+        assert service_manager.toolbar.actions['theme_combo_box'].isVisible() is True, \
-                        'The visibility should be True')
+            'The visibility should be True'