diff --git a/tests/functional/openlp_plugins/alerts/test_manager.py b/tests/functional/openlp_plugins/alerts/test_manager.py index c286e81cd..9125a81e0 100644 --- a/tests/functional/openlp_plugins/alerts/test_manager.py +++ b/tests/functional/openlp_plugins/alerts/test_manager.py @@ -51,7 +51,7 @@ class TestAlertManager(TestCase): alert_manager.alert_text('') # THEN: the display should not have been triggered - self.assertFalse(alert_manager.display_alert.called, 'The Alert should not have been called') + assert alert_manager.display_alert.called is False, 'The Alert should not have been called' def test_trigger_message_text(self): """ @@ -65,7 +65,7 @@ class TestAlertManager(TestCase): alert_manager.alert_text(['This is a string']) # THEN: the display should have been triggered - self.assertTrue(alert_manager.display_alert.called, 'The Alert should have been called') + assert alert_manager.display_alert.called is True, 'The Alert should have been called' def test_line_break_message_text(self): """ diff --git a/tests/functional/openlp_plugins/bibles/test_mediaitem.py b/tests/functional/openlp_plugins/bibles/test_mediaitem.py index 95f047cb0..5e14f313f 100755 --- a/tests/functional/openlp_plugins/bibles/test_mediaitem.py +++ b/tests/functional/openlp_plugins/bibles/test_mediaitem.py @@ -1375,7 +1375,7 @@ class TestMediaItem(TestCase, TestMixin): assert self.media_item.search_results == [mocked_verse_1] assert self.media_item.second_search_results == [mocked_verse_1a] assert self.mocked_log.debug.call_count == 2 - assertTrue(self.mocked_main_window.information_message.called) + assert self.mocked_main_window.information_message.called is True mocked_display_results.assert_called_once_with() def test_on_search_edit_text_changed_search_while_typing_disabled(self): @@ -1391,7 +1391,7 @@ class TestMediaItem(TestCase, TestMixin): self.media_item.on_search_edit_text_changed() # THEN: The method should not have checked if the timer is active - assertFalse(self.media_item.search_timer.isActive.called) + assert self.media_item.search_timer.isActive.called is False def test_on_search_edit_text_changed_search_while_typing_enabled(self): """ @@ -1441,7 +1441,7 @@ class TestMediaItem(TestCase, TestMixin): self.media_item.display_results() # THEN: No items should be added to the list - assertFalse(self.media_item.list_view.addItem.called) + assert self.media_item.list_view.addItem.called is False def test_display_results_results(self): """ diff --git a/tests/functional/openlp_plugins/images/test_lib.py b/tests/functional/openlp_plugins/images/test_lib.py index 09092a0f0..9be64b80a 100644 --- a/tests/functional/openlp_plugins/images/test_lib.py +++ b/tests/functional/openlp_plugins/images/test_lib.py @@ -164,8 +164,7 @@ class TestImageMediaItem(TestCase): self.media_item.save_new_images_list(image_list, reload_list=False) # THEN: load_full_list() should not have been called - self.assertEquals(self.media_item.manager.save_object.call_count, 2, - 'load_full_list() should have been called only once') + assert self.media_item.manager.save_object.call_count == 2, 'load_full_list() should have been called only once' def test_on_reset_click(self): """ @@ -277,7 +276,7 @@ class TestImageMediaItem(TestCase): # THEN: A QTreeWidgetItem should be created with the above model object as it's data assert isinstance(item, QtWidgets.QTreeWidgetItem) - self.assertEqual('test_file_1.jpg', item.text(0)) + assert 'test_file_1.jpg' == item.text(0) item_data = item.data(0, QtCore.Qt.UserRole) assert isinstance(item_data, ImageFilenames) assert 1 == item_data.id diff --git a/tests/functional/openlp_plugins/media/test_mediaplugin.py b/tests/functional/openlp_plugins/media/test_mediaplugin.py index 2fc170272..d68be3837 100644 --- a/tests/functional/openlp_plugins/media/test_mediaplugin.py +++ b/tests/functional/openlp_plugins/media/test_mediaplugin.py @@ -71,7 +71,7 @@ class MediaPluginTest(TestCase, TestMixin): result = process_check_binary('MediaInfo') # THEN: The the result should be True - self.assertTrue(result, 'Mediainfo should have been found') + assert result is True, 'Mediainfo should have been found' @patch('openlp.plugins.media.mediaplugin.check_binary_exists') def test_process_check_binary_fail(self, mocked_checked_binary_exists): @@ -84,4 +84,4 @@ class MediaPluginTest(TestCase, TestMixin): result = process_check_binary("MediaInfo1") # THEN: The the result should be True - self.assertFalse(result, "Mediainfo should not have been found") + assert result is False, "Mediainfo should not have been found" diff --git a/tests/functional/openlp_plugins/presentations/test_mediaitem.py b/tests/functional/openlp_plugins/presentations/test_mediaitem.py index 7fe9f208e..e2035d92b 100644 --- a/tests/functional/openlp_plugins/presentations/test_mediaitem.py +++ b/tests/functional/openlp_plugins/presentations/test_mediaitem.py @@ -81,11 +81,11 @@ class TestMediaItem(TestCase, TestMixin): self.media_item.build_file_mask_string() # THEN: The file mask should be generated correctly - assertIn('*.odp', self.media_item.on_new_file_masks, 'The file mask should contain the odp extension') - assertIn('*.ppt', self.media_item.on_new_file_masks, 'The file mask should contain the ppt extension') - assertIn('*.pdf', self.media_item.on_new_file_masks, 'The file mask should contain the pdf extension') - assertIn('*.xps', self.media_item.on_new_file_masks, 'The file mask should contain the xps extension') - assertIn('*.oxps', self.media_item.on_new_file_masks, 'The file mask should contain the oxps extension') + assert '*.odp' in self.media_item.on_new_file_masks, 'The file mask should contain the odp extension' + assert '*.ppt' in self.media_item.on_new_file_masks, 'The file mask should contain the ppt extension' + assert '*.pdf' in self.media_item.on_new_file_masks, 'The file mask should contain the pdf extension' + assert '*.xps' in self.media_item.on_new_file_masks, 'The file mask should contain the xps extension' + assert '*.oxps' in self.media_item.on_new_file_masks, 'The file mask should contain the oxps extension' def test_clean_up_thumbnails(self): """ diff --git a/tests/functional/openlp_plugins/presentations/test_messagelistener.py b/tests/functional/openlp_plugins/presentations/test_messagelistener.py index 28638e081..56552a46b 100644 --- a/tests/functional/openlp_plugins/presentations/test_messagelistener.py +++ b/tests/functional/openlp_plugins/presentations/test_messagelistener.py @@ -73,7 +73,7 @@ class TestMessageListener(TestCase, TestMixin): ml.startup([mock_item, False, False, False]) # THEN: The controllers will be setup. - self.assertTrue(len(controllers), 'We have loaded a controller') + assert len(controllers) > 0, 'We have loaded a controller' @patch('openlp.plugins.presentations.lib.mediaitem.MessageListener._setup') def test_start_presentation_with_no_player(self, media_mock): @@ -105,7 +105,7 @@ class TestMessageListener(TestCase, TestMixin): ml.startup([mock_item, False, False, False]) # THEN: The controllers will be setup. - self.assertTrue(len(controllers), 'We have loaded a controller') + assert len(controllers) > 0, 'We have loaded a controller' @patch('openlp.plugins.presentations.lib.mediaitem.MessageListener._setup') def test_start_pdf_presentation(self, media_mock): @@ -125,7 +125,7 @@ class TestMessageListener(TestCase, TestMixin): ml.startup([mock_item, False, False, False]) # THEN: The handler should be set to None - self.assertIsNone(ml.handler, 'The handler should be None') + assert ml.handler is None, 'The handler should be None' class TestController(TestCase, TestMixin): diff --git a/tests/functional/openlp_plugins/presentations/test_pdfcontroller.py b/tests/functional/openlp_plugins/presentations/test_pdfcontroller.py index 11d925682..4d35bb6c9 100644 --- a/tests/functional/openlp_plugins/presentations/test_pdfcontroller.py +++ b/tests/functional/openlp_plugins/presentations/test_pdfcontroller.py @@ -131,7 +131,7 @@ class TestPdfController(TestCase, TestMixin): loaded = document.load_presentation() # THEN: The load should succeed and pictures should be created and have been scales to fit the screen - self.assertTrue(loaded, 'The loading of the PDF should succeed.') + assert loaded is True, 'The loading of the PDF should succeed.' image = QtGui.QImage(os.path.join(str(self.temp_folder_path), 'pdf_test1.pdf', 'mainslide001.png')) # Based on the converter used the resolution will differ a bit if controller.gsbin: diff --git a/tests/functional/openlp_plugins/presentations/test_powerpointcontroller.py b/tests/functional/openlp_plugins/presentations/test_powerpointcontroller.py index 27863d809..544c37821 100644 --- a/tests/functional/openlp_plugins/presentations/test_powerpointcontroller.py +++ b/tests/functional/openlp_plugins/presentations/test_powerpointcontroller.py @@ -249,7 +249,7 @@ class TestPowerpointDocument(TestCase, TestMixin): doc.goto_slide(1) # THEN: next_step() should be call to try to advance to the next effect. - assertTrue(doc.next_step.called, 'next_step() should have been called!') + assert doc.next_step.called, 'next_step() should have been called!' is True def test_blank_screen(self): """ diff --git a/tests/functional/openlp_plugins/presentations/test_pptviewcontroller.py b/tests/functional/openlp_plugins/presentations/test_pptviewcontroller.py index c188a9f50..99f285320 100644 --- a/tests/functional/openlp_plugins/presentations/test_pptviewcontroller.py +++ b/tests/functional/openlp_plugins/presentations/test_pptviewcontroller.py @@ -164,7 +164,7 @@ class TestPptviewDocument(TestCase): result = instance.load_presentation() # THEN: The temp folder should be created and PptviewDocument.load_presentation should return False - self.assertFalse(result) + assert result is False def test_create_titles_and_notes(self): """ diff --git a/tests/functional/openlp_plugins/presentations/test_presentationcontroller.py b/tests/functional/openlp_plugins/presentations/test_presentationcontroller.py index 7ff3923aa..cd1caaebf 100644 --- a/tests/functional/openlp_plugins/presentations/test_presentationcontroller.py +++ b/tests/functional/openlp_plugins/presentations/test_presentationcontroller.py @@ -151,7 +151,7 @@ class TestPresentationController(TestCase): result_titles, result_notes = self.document.get_titles_and_notes() # THEN: it should return two empty lists - assertIs(type(result_titles), list, 'result_titles should be a list') + assert type(result_titles) is list, 'result_titles should be a list' class TestPresentationDocument(TestCase): @@ -226,4 +226,4 @@ class TestPresentationDocument(TestCase): result = instance.load_presentation() # THEN: load_presentation should return false - assertFalse(result, "PresentationDocument.load_presentation should return false.") + assert result is False, "PresentationDocument.load_presentation should return false." diff --git a/tests/functional/openlp_plugins/songs/test_db.py b/tests/functional/openlp_plugins/songs/test_db.py index 797359139..e8b22564e 100644 --- a/tests/functional/openlp_plugins/songs/test_db.py +++ b/tests/functional/openlp_plugins/songs/test_db.py @@ -66,10 +66,10 @@ class TestDB(TestCase): song.add_author(author) # THEN: The author should have been added with author_type=None - self.assertEqual(1, len(song.authors_songs)) - self.assertEqual("Max", song.authors_songs[0].author.first_name) - self.assertEqual("Mustermann", song.authors_songs[0].author.last_name) - self.assertIsNone(song.authors_songs[0].author_type) + assert 1 == len(song.authors_songs) + assert "Max" == song.authors_songs[0].author.first_name + assert "Mustermann" == song.authors_songs[0].author.last_name + assert song.authors_songs[0].author_type is None def test_add_author_with_type(self): """ @@ -86,10 +86,10 @@ class TestDB(TestCase): song.add_author(author, AuthorType.Words) # THEN: The author should have been added with author_type=None - self.assertEqual(1, len(song.authors_songs)) - self.assertEqual("Max", song.authors_songs[0].author.first_name) - self.assertEqual("Mustermann", song.authors_songs[0].author.last_name) - self.assertEqual(AuthorType.Words, song.authors_songs[0].author_type) + assert 1 == len(song.authors_songs) + assert "Max" == song.authors_songs[0].author.first_name + assert "Mustermann" == song.authors_songs[0].author.last_name + assert AuthorType.Words == song.authors_songs[0].author_type def test_remove_author(self): """ @@ -105,7 +105,7 @@ class TestDB(TestCase): song.remove_author(author) # THEN: It should have been removed - self.assertEqual(0, len(song.authors_songs)) + assert 0 == len(song.authors_songs) def test_remove_author_with_type(self): """ @@ -122,8 +122,8 @@ class TestDB(TestCase): song.remove_author(author, AuthorType.Translation) # THEN: It should have been removed and the other author should still be there - self.assertEqual(1, len(song.authors_songs)) - self.assertEqual(None, song.authors_songs[0].author_type) + assert 1 == len(song.authors_songs) + assert song.authors_songs[0].author_type is None def test_get_author_type_from_translated_text(self): """ @@ -136,7 +136,7 @@ class TestDB(TestCase): author_type = AuthorType.from_translated_text(author_type_name) # THEN: The type should be correct - self.assertEqual(author_type, AuthorType.Words) + assert author_type == AuthorType.Words def test_author_get_display_name(self): """ @@ -150,7 +150,7 @@ class TestDB(TestCase): display_name = author.get_display_name() # THEN: It should return only the name - self.assertEqual("John Doe", display_name) + assert "John Doe" == display_name def test_author_get_display_name_with_type_words(self): """ @@ -164,7 +164,7 @@ class TestDB(TestCase): display_name = author.get_display_name(AuthorType.Words) # THEN: It should return the name with the type in brackets - self.assertEqual("John Doe (Words)", display_name) + assert "John Doe (Words)" == display_name def test_author_get_display_name_with_type_translation(self): """ @@ -178,7 +178,7 @@ class TestDB(TestCase): display_name = author.get_display_name(AuthorType.Translation) # THEN: It should return the name with the type in brackets - self.assertEqual("John Doe (Translation)", display_name) + assert "John Doe (Translation)" == display_name def test_add_songbooks(self): """ @@ -195,7 +195,7 @@ class TestDB(TestCase): song.add_songbook_entry(songbook, "550A") # THEN: The song should have two songbook entries - self.assertEqual(len(song.songbook_entries), 2, 'There should be two Songbook entries.') + assert len(song.songbook_entries) == 2, 'There should be two Songbook entries.' def test_upgrade_old_song_db(self): """ @@ -211,8 +211,7 @@ class TestDB(TestCase): updated_to_version, latest_version = upgrade_db(db_url, upgrade) # THEN: the song db should have been upgraded to the latest version - self.assertEqual(updated_to_version, latest_version, - 'The song DB should have been upgrade to the latest version') + assert updated_to_version == latest_version, 'The song DB should have been upgrade to the latest version' def test_upgrade_invalid_song_db(self): """ @@ -228,5 +227,4 @@ class TestDB(TestCase): updated_to_version, latest_version = upgrade_db(db_url, upgrade) # THEN: the song db should have been upgraded to the latest version without errors - self.assertEqual(updated_to_version, latest_version, - 'The song DB should have been upgrade to the latest version') + assert updated_to_version == latest_version, 'The song DB should have been upgrade to the latest version' diff --git a/tests/functional/openlp_plugins/songs/test_editsongform.py b/tests/functional/openlp_plugins/songs/test_editsongform.py index 5a5e861c7..86ef0794a 100644 --- a/tests/functional/openlp_plugins/songs/test_editsongform.py +++ b/tests/functional/openlp_plugins/songs/test_editsongform.py @@ -64,7 +64,7 @@ class TestEditSongForm(TestCase, TestMixin): valid = self.edit_song_form._validate_tags(tags) # THEN they should be valid - self.assertTrue(valid, "The tags list should be valid") + assert valid is True, "The tags list should be valid" def test_validate_nonmatching_tags(self): # Given a set of tags @@ -74,7 +74,7 @@ class TestEditSongForm(TestCase, TestMixin): valid = self.edit_song_form._validate_tags(tags) # THEN they should be valid - self.assertTrue(valid, "The tags list should be valid") + assert valid is True, "The tags list should be valid" @patch('openlp.plugins.songs.forms.editsongform.set_case_insensitive_completer') def test_load_objects(self, mocked_set_case_insensitive_completer): diff --git a/tests/functional/openlp_plugins/songs/test_ewimport.py b/tests/functional/openlp_plugins/songs/test_ewimport.py index befa5b1f7..67ba909ff 100644 --- a/tests/functional/openlp_plugins/songs/test_ewimport.py +++ b/tests/functional/openlp_plugins/songs/test_ewimport.py @@ -165,11 +165,10 @@ class TestEasyWorshipSongImport(TestCase): field_desc_entry = FieldDescEntry(name, field_type, size) # THEN: - self.assertIsNotNone(field_desc_entry, 'Import should not be none') - self.assertEqual(field_desc_entry.name, name, 'FieldDescEntry.name should be the same as the name argument') - self.assertEqual(field_desc_entry.field_type, field_type, - 'FieldDescEntry.type should be the same as the type argument') - self.assertEqual(field_desc_entry.size, size, 'FieldDescEntry.size should be the same as the size argument') + assert field_desc_entry is not None, 'Import should not be none' + assert field_desc_entry.name, name == 'FieldDescEntry.name should be the same as the name argument' + assert field_desc_entry.field_type == field_type, 'FieldDescEntry.type should be the same as the type argument' + assert field_desc_entry.size == size, 'FieldDescEntry.size should be the same as the size argument' def test_create_importer(self): """ @@ -183,7 +182,7 @@ class TestEasyWorshipSongImport(TestCase): importer = EasyWorshipSongImport(mocked_manager, file_paths=[]) # THEN: The importer object should not be None - self.assertIsNotNone(importer, 'Import should not be none') + assert importer is not None, 'Import should not be none' def test_find_field_exists(self): """ @@ -201,7 +200,7 @@ class TestEasyWorshipSongImport(TestCase): for field_name in existing_fields: # THEN: The item corresponding the index returned should have the same name attribute - self.assertEqual(importer.field_descriptions[importer.db_find_field(field_name)].name, field_name) + assert importer.field_descriptions[importer.db_find_field(field_name)].name == field_name def test_find_non_existing_field(self): """ @@ -236,7 +235,7 @@ class TestEasyWorshipSongImport(TestCase): # THEN: db_set_record_struct should return None and Struct should be called with a value representing # the list of field descriptions - self.assertIsNone(return_value, 'db_set_record_struct should return None') + assert return_value is None, 'db_set_record_struct should return None' mocked_struct.Struct.assert_called_with('>50sHIB250s250s10sQ') @patch('openlp.plugins.songs.lib.importers.easyworship.SongImport') @@ -257,9 +256,8 @@ class TestEasyWorshipSongImport(TestCase): return_value = importer.db_get_field(field_index) # THEN: db_get_field should return the known results - self.assertEqual(return_value, result, - 'db_get_field should return "%s" when called with "%s"' % - (result, TEST_FIELDS[field_index])) + assert return_value == result, 'db_get_field should return "%s" when called with "%s"' % \ + (result, TEST_FIELDS[field_index]) @patch('openlp.plugins.songs.lib.importers.easyworship.SongImport') def test_get_memo_field(self, MockSongImport): @@ -285,7 +283,7 @@ class TestEasyWorshipSongImport(TestCase): # THEN: db_get_field should return the appropriate value with the appropriate mocked objects being # called - self.assertEqual(importer.db_get_field(field_index), get_field_result) + assert importer.db_get_field(field_index) == get_field_result for call in get_field_read_calls: mocked_memo_file.read.assert_any_call(call) for call in get_field_seek_calls: @@ -330,7 +328,7 @@ class TestEasyWorshipSongImport(TestCase): mocked_stat.return_value.st_size = 0x7FF # THEN: do_import should return None having called Path.stat() - self.assertIsNone(importer.do_import(), 'do_import should return None when db_size is less than 0x800') + assert importer.do_import() is None, 'do_import should return None when db_size is less than 0x800' mocked_stat.assert_called_once_with() @patch('openlp.plugins.songs.lib.importers.easyworship.SongImport') @@ -353,11 +351,10 @@ class TestEasyWorshipSongImport(TestCase): # THEN: do_import should return None having called closed the open files db and memo files. for effect in struct_unpack_return_values: - self.assertIsNone(importer.do_import(), 'do_import should return None when db_size is less than 0x800') - self.assertEqual(mocked_open().close.call_count, 2, - 'The open db and memo files should have been closed') + assert importer.do_import() is None, 'do_import should return None when db_size is less than 0x800' + assert mocked_open().close.call_count == 2, 'The open db and memo files should have been closed' mocked_open().close.reset_mock() - self.assertIs(mocked_open().seek.called, False, 'db_file.seek should not have been called.') + assert mocked_open().seek.called is False, 'db_file.seek should not have been called.' @patch('openlp.plugins.songs.lib.importers.easyworship.SongImport') @patch('openlp.plugins.songs.lib.importers.easyworship.Path.is_file', return_value=True) @@ -383,7 +380,7 @@ class TestEasyWorshipSongImport(TestCase): mocked_retrieve_windows_encoding.return_value = False # THEN: do_import should return None having called retrieve_windows_encoding with the correct encoding. - self.assertIsNone(importer.do_import(), 'do_import should return None when db_size is less than 0x800') + assert importer.do_import() is None, 'do_import should return None when db_size is less than 0x800' mocked_retrieve_windows_encoding.assert_any_call(encoding) def test_db_file_import(self): @@ -425,7 +422,7 @@ class TestEasyWorshipSongImport(TestCase): # THEN: do_import should return none, the song data should be as expected, and finish should have been # called. - self.assertIsNone(import_result, 'do_import should return None when it has completed') + assert import_result is None, 'do_import should return None when it has completed' for song_data in SONG_TEST_DATA: title = song_data['title'] author_calls = song_data['authors'] @@ -433,19 +430,18 @@ class TestEasyWorshipSongImport(TestCase): ccli_number = song_data['ccli_number'] add_verse_calls = song_data['verses'] verse_order_list = song_data['verse_order_list'] - self.assertIn(title, importer._title_assignment_list, 'title for %s should be "%s"' % (title, title)) + assert title in importer._title_assignment_list, 'title for %s should be "%s"' % (title, title) for author in author_calls: mocked_add_author.assert_any_call(author) if song_copyright: - self.assertEqual(importer.copyright, song_copyright) + assert importer.copyright == song_copyright if ccli_number: - self.assertEqual(importer.ccli_number, ccli_number, - 'ccli_number for %s should be %s' % (title, ccli_number)) + assert importer.ccli_number == ccli_number, 'ccli_number for %s should be %s' % (title, ccli_number) for verse_text, verse_tag in add_verse_calls: mocked_add_verse.assert_any_call(verse_text, verse_tag) if verse_order_list: - self.assertEqual(importer.verse_order_list, verse_order_list, - 'verse_order_list for %s should be %s' % (title, verse_order_list)) + assert importer.verse_order_list == verse_order_list, \ + 'verse_order_list for %s should be %s' % (title, verse_order_list) mocked_finish.assert_called_with() @patch('openlp.plugins.songs.lib.importers.easyworship.SongImport') @@ -481,8 +477,8 @@ class TestEasyWorshipSongImport(TestCase): # THEN: do_import should return none, the song data should be as expected, and finish should have been # called. title = EWS_SONG_TEST_DATA['title'] - self.assertIsNone(import_result, 'do_import should return None when it has completed') - self.assertIn(title, importer._title_assignment_list, 'title for should be "%s"' % title) + assert import_result is None, 'do_import should return None when it has completed' + assert title in importer._title_assignment_list, 'title for should be "%s"' % title mocked_add_author.assert_any_call(EWS_SONG_TEST_DATA['authors'][0]) for verse_text, verse_tag in EWS_SONG_TEST_DATA['verses']: mocked_add_verse.assert_any_call(verse_text, verse_tag) @@ -505,4 +501,4 @@ class TestEasyWorshipSongImport(TestCase): importer.set_song_import_object('Test Author', b'Det som var fr\x86n begynnelsen') # THEN: The import should fail - self.assertEquals(importer.entry_error_log, 'Unexpected data formatting.', 'Import should fail') + assert importer.entry_error_log == 'Unexpected data formatting.', 'Import should fail' diff --git a/tests/functional/openlp_plugins/songs/test_foilpresenterimport.py b/tests/functional/openlp_plugins/songs/test_foilpresenterimport.py index d3d705722..028bf62db 100644 --- a/tests/functional/openlp_plugins/songs/test_foilpresenterimport.py +++ b/tests/functional/openlp_plugins/songs/test_foilpresenterimport.py @@ -106,7 +106,7 @@ class TestFoilPresenter(TestCase): foil_presenter_instance = FoilPresenter(mocked_manager, mocked_song_import) # THEN: The instance should not be None - self.assertIsNotNone(foil_presenter_instance, 'foil_presenter instance should not be none') + assert foil_presenter_instance is not None, 'foil_presenter instance should not be none' def test_no_xml(self): """ @@ -122,7 +122,7 @@ class TestFoilPresenter(TestCase): result = foil_presenter_instance.xml_to_song(arg) # Then: xml_to_song should return False - self.assertEqual(result, None, 'xml_to_song should return None when called with %s' % arg) + assert result is None, 'xml_to_song should return None when called with %s' % arg def test_encoding_declaration_removal(self): """ @@ -169,6 +169,6 @@ class TestFoilPresenter(TestCase): result = foil_presenter_instance._process_lyrics(mock_foilpresenterfolie, mocked_song) # THEN: _process_lyrics should return None and the song_import log_error method should have been called once - self.assertIsNone(result) + assert result is None self.mocked_song_import.log_error.assert_called_once_with('Element Text', 'Translated String') self.process_lyrics_patcher.start() diff --git a/tests/functional/openlp_plugins/songs/test_lib.py b/tests/functional/openlp_plugins/songs/test_lib.py index 334282a44..50a579125 100644 --- a/tests/functional/openlp_plugins/songs/test_lib.py +++ b/tests/functional/openlp_plugins/songs/test_lib.py @@ -63,7 +63,7 @@ class TestLib(TestCase): result = clean_string(dirty_string) # THEN: The string should be cleaned up and lower-cased - self.assertEqual(result, 'aint gonna find you there ', 'The string should be cleaned up properly') + assert result == 'aint gonna find you there ', 'The string should be cleaned up properly' def test_clean_title(self): """ @@ -76,7 +76,7 @@ class TestLib(TestCase): result = clean_title(dirty_string) # THEN: The string should be cleaned up - self.assertEqual(result, 'This is a dirty string', 'The title should be cleaned up properly: "%s"' % result) + assert result == 'This is a dirty string', 'The title should be cleaned up properly: "%s"' % result def test_songs_probably_equal_same_song(self): """ @@ -275,7 +275,7 @@ class TestLib(TestCase): new_chord = transpose_chord(chord, 1, 'english') # THEN: The chord should be transposed up one note - self.assertEqual(new_chord, 'C#', 'The chord should be transposed up.') + assert new_chord == 'C#', 'The chord should be transposed up.' def test_transpose_chord_up_adv(self): """ @@ -288,7 +288,7 @@ class TestLib(TestCase): new_chord = transpose_chord(chord, 1, 'english') # THEN: The chord should be transposed up one note - self.assertEqual(new_chord, '(C#/E)', 'The chord should be transposed up.') + assert new_chord == '(C#/E)', 'The chord should be transposed up.' def test_transpose_chord_down(self): """ @@ -301,7 +301,7 @@ class TestLib(TestCase): new_chord = transpose_chord(chord, -1, 'english') # THEN: The chord should be transposed down one note - self.assertEqual(new_chord, 'B', 'The chord should be transposed down.') + assert new_chord == 'B', 'The chord should be transposed down.' def test_transpose_chord_error(self): """ @@ -314,8 +314,8 @@ class TestLib(TestCase): # THEN: An exception should be raised with self.assertRaises(ValueError) as err: new_chord = transpose_chord(chord, -1, 'english') - self.assertEqual(err.exception.args[0], '\'T\' is not in list', - 'ValueError exception should have been thrown for invalid chord') + assert err.exception.args[0] == '\'T\' is not in list', \ + 'ValueError exception should have been thrown for invalid chord' @patch('openlp.plugins.songs.lib.transpose_verse') @patch('openlp.plugins.songs.lib.Settings') @@ -361,13 +361,13 @@ class TestVerseType(TestCase): result = VerseType.translated_tag('v') # THEN: The result should be "V" - self.assertEqual(result, 'V', 'The result should be "V"') + assert result == 'V', 'The result should be "V"' # WHEN: We run the translated_tag() method with a "chorus" result = VerseType.translated_tag('c') # THEN: The result should be "C" - self.assertEqual(result, 'C', 'The result should be "C"') + assert result == 'C', 'The result should be "C"' def test_translated_invalid_tag(self): """ @@ -381,7 +381,7 @@ class TestVerseType(TestCase): result = VerseType.translated_tag('z') # THEN: The result should be "O" - self.assertEqual(result, 'O', 'The result should be "O", but was "%s"' % result) + assert result == 'O', 'The result should be "O", but was "%s"' % result def test_translated_invalid_tag_with_specified_default(self): """ @@ -395,7 +395,7 @@ class TestVerseType(TestCase): result = VerseType.translated_tag('q', VerseType.Bridge) # THEN: The result should be "B" - self.assertEqual(result, 'B', 'The result should be "B", but was "%s"' % result) + assert result == 'B', 'The result should be "B", but was "%s"' % result def test_translated_invalid_tag_with_invalid_default(self): """ @@ -409,7 +409,7 @@ class TestVerseType(TestCase): result = VerseType.translated_tag('q', 29) # THEN: The result should be "O" - self.assertEqual(result, 'O', 'The result should be "O", but was "%s"' % result) + assert result == 'O', 'The result should be "O", but was "%s"' % result def test_translated_name(self): """ @@ -423,13 +423,13 @@ class TestVerseType(TestCase): result = VerseType.translated_name('v') # THEN: The result should be "Verse" - self.assertEqual(result, 'Verse', 'The result should be "Verse"') + assert result == 'Verse', 'The result should be "Verse"' # WHEN: We run the translated_name() method with a "chorus" result = VerseType.translated_name('c') # THEN: The result should be "Chorus" - self.assertEqual(result, 'Chorus', 'The result should be "Chorus"') + assert result == 'Chorus', 'The result should be "Chorus"' def test_translated_invalid_name(self): """ @@ -443,7 +443,7 @@ class TestVerseType(TestCase): result = VerseType.translated_name('z') # THEN: The result should be "Other" - self.assertEqual(result, 'Other', 'The result should be "Other", but was "%s"' % result) + assert result == 'Other', 'The result should be "Other", but was "%s"' % result def test_translated_invalid_name_with_specified_default(self): """ @@ -457,7 +457,7 @@ class TestVerseType(TestCase): result = VerseType.translated_name('q', VerseType.Bridge) # THEN: The result should be "Bridge" - self.assertEqual(result, 'Bridge', 'The result should be "Bridge", but was "%s"' % result) + assert result == 'Bridge', 'The result should be "Bridge", but was "%s"' % result def test_translated_invalid_name_with_invalid_default(self): """ @@ -471,7 +471,7 @@ class TestVerseType(TestCase): result = VerseType.translated_name('q', 29) # THEN: The result should be "Other" - self.assertEqual(result, 'Other', 'The result should be "Other", but was "%s"' % result) + assert result == 'Other', 'The result should be "Other", but was "%s"' % result def test_from_tag(self): """ @@ -485,7 +485,7 @@ class TestVerseType(TestCase): result = VerseType.from_tag('v') # THEN: The result should be VerseType.Verse - self.assertEqual(result, VerseType.Verse, 'The result should be VerseType.Verse, but was "%s"' % result) + assert result == VerseType.Verse, 'The result should be VerseType.Verse, but was "%s"' % result def test_from_tag_with_invalid_tag(self): """ @@ -499,7 +499,7 @@ class TestVerseType(TestCase): result = VerseType.from_tag('w') # THEN: The result should be VerseType.Other - self.assertEqual(result, VerseType.Other, 'The result should be VerseType.Other, but was "%s"' % result) + assert result == VerseType.Other, 'The result should be VerseType.Other, but was "%s"' % result def test_from_tag_with_specified_default(self): """ @@ -513,7 +513,7 @@ class TestVerseType(TestCase): result = VerseType.from_tag('x', VerseType.Chorus) # THEN: The result should be VerseType.Chorus - self.assertEqual(result, VerseType.Chorus, 'The result should be VerseType.Chorus, but was "%s"' % result) + assert result == VerseType.Chorus, 'The result should be VerseType.Chorus, but was "%s"' % result def test_from_tag_with_invalid_intdefault(self): """ @@ -527,7 +527,7 @@ class TestVerseType(TestCase): result = VerseType.from_tag('m', 29) # THEN: The result should be VerseType.Other - self.assertEqual(result, VerseType.Other, 'The result should be VerseType.Other, but was "%s"' % result) + assert result == VerseType.Other, 'The result should be VerseType.Other, but was "%s"' % result def test_from_tag_with_invalid_default(self): """ @@ -541,7 +541,7 @@ class TestVerseType(TestCase): result = VerseType.from_tag('@', 'asdf') # THEN: The result should be VerseType.Other - self.assertEqual(result, VerseType.Other, 'The result should be VerseType.Other, but was "%s"' % result) + assert result == VerseType.Other, 'The result should be VerseType.Other, but was "%s"' % result def test_from_tag_with_none_default(self): """ @@ -555,7 +555,7 @@ class TestVerseType(TestCase): result = VerseType.from_tag('m', None) # THEN: The result should be None - self.assertIsNone(result, 'The result should be None, but was "%s"' % result) + assert result is None, 'The result should be None, but was "%s"' % result @patch('openlp.plugins.songs.lib.VerseType.translated_tags', new_callable=PropertyMock, return_value=['x']) def test_from_loose_input_with_invalid_input(self, mocked_translated_tags): @@ -567,7 +567,7 @@ class TestVerseType(TestCase): result = VerseType.from_loose_input('m', None) # THEN: The result should be None - self.assertIsNone(result, 'The result should be None, but was "%s"' % result) + assert result is None, 'The result should be None, but was "%s"' % result @patch('openlp.plugins.songs.lib.VerseType.translated_tags', new_callable=PropertyMock, return_value=['x']) def test_from_loose_input_with_valid_input(self, mocked_translated_tags): @@ -579,4 +579,4 @@ class TestVerseType(TestCase): result = VerseType.from_loose_input('v') # THEN: The result should be a Verse - self.assertEqual(result, VerseType.Verse, 'The result should be a verse, but was "%s"' % result) + assert result == VerseType.Verse, 'The result should be a verse, but was "%s"' % result diff --git a/tests/functional/openlp_plugins/songs/test_mediashout.py b/tests/functional/openlp_plugins/songs/test_mediashout.py index 8fc452ea4..4ce5685a4 100644 --- a/tests/functional/openlp_plugins/songs/test_mediashout.py +++ b/tests/functional/openlp_plugins/songs/test_mediashout.py @@ -54,7 +54,7 @@ class TestMediaShoutImport(TestCase): importer = MediaShoutImport(MagicMock(), file_path='mediashout.db') # THEN: It should not be None - self.assertIsNotNone(importer) + assert importer is not None @patch('openlp.plugins.songs.lib.importers.mediashout.pyodbc') def test_do_import_fails_to_connect(self, mocked_pyodbc): @@ -112,7 +112,7 @@ class TestMediaShoutImport(TestCase): call('SELECT Name FROM Groups INNER JOIN SongGroups ON SongGroups.GroupId = Groups.GroupId ' 'WHERE SongGroups.Record = ?', 1.0) ] - self.assertEqual(expected_execute_calls, mocked_cursor.execute.call_args_list) + assert expected_execute_calls == mocked_cursor.execute.call_args_list mocked_process_song.assert_called_once_with(song, [verse], [play_order], [theme, group]) @patch('openlp.plugins.songs.lib.importers.mediashout.pyodbc') @@ -172,16 +172,16 @@ class TestMediaShoutImport(TestCase): # THEN: It should be added to the database mocked_set_defaults.assert_called_once_with() - self.assertEqual('Amazing Grace', importer.title) + assert 'Amazing Grace' == importer.title mocked_parse_author.assert_called_once_with('William Wilberforce') mocked_add_copyright.assert_called_once_with('Public Domain') - self.assertEqual('Great old hymn', importer.comments) - self.assertEqual(['Grace', 'Hymns'], importer.topics) - self.assertEqual('Hymns', importer.song_book_name) - self.assertEqual('', importer.song_number) + assert 'Great old hymn' == importer.comments + assert ['Grace', 'Hymns'] == importer.topics + assert 'Hymns' == importer.song_book_name + assert '' == importer.song_number mocked_add_verse.assert_called_once_with( 'Amazing grace, how sweet the sound\nThat saved a wretch like me', 'V1') - self.assertEqual(['V1'], importer.verse_order_list) + assert ['V1'] == importer.verse_order_list mocked_finish.assert_called_once_with() def test_process_song_with_song_number(self): @@ -214,14 +214,14 @@ class TestMediaShoutImport(TestCase): # THEN: It should be added to the database mocked_set_defaults.assert_called_once_with() - self.assertEqual('Amazing Grace', importer.title) + assert 'Amazing Grace' == importer.title mocked_parse_author.assert_called_once_with('William Wilberforce') mocked_add_copyright.assert_called_once_with('Public Domain') - self.assertEqual('Great old hymn', importer.comments) - self.assertEqual(['Grace', 'Hymns'], importer.topics) - self.assertEqual('Hymns', importer.song_book_name) - self.assertEqual('2', importer.song_number) + assert 'Great old hymn' == importer.comments + assert ['Grace', 'Hymns'] == importer.topics + assert 'Hymns' == importer.song_book_name + assert '2' == importer.song_number mocked_add_verse.assert_called_once_with( 'Amazing grace, how sweet the sound\nThat saved a wretch like me', 'V1') - self.assertEqual(['V1'], importer.verse_order_list) + assert ['V1'], importer.verse_order_list mocked_finish.assert_called_once_with() diff --git a/tests/functional/openlp_plugins/songs/test_openlpimporter.py b/tests/functional/openlp_plugins/songs/test_openlpimporter.py index 590d09b79..eba2b1cfa 100644 --- a/tests/functional/openlp_plugins/songs/test_openlpimporter.py +++ b/tests/functional/openlp_plugins/songs/test_openlpimporter.py @@ -51,7 +51,7 @@ class TestOpenLPImport(TestCase): importer = OpenLPSongImport(mocked_manager, file_paths=[]) # THEN: The importer object should not be None - self.assertIsNotNone(importer, 'Import should not be none') + assert importer is not None, 'Import should not be none' def test_invalid_import_source(self): """ @@ -70,6 +70,6 @@ class TestOpenLPImport(TestCase): importer.import_source = source # THEN: do_import should return none and the progress bar maximum should not be set. - self.assertIsNone(importer.do_import(), 'do_import should return None when import_source is not a list') - self.assertEqual(mocked_import_wizard.progress_bar.setMaximum.called, False, - 'setMaximum on import_wizard.progress_bar should not have been called') + assert importer.do_import() is None, 'do_import should return None when import_source is not a list' + assert mocked_import_wizard.progress_bar.setMaximum.called == False, \ + 'setMaximum on import_wizard.progress_bar should not have been called' diff --git a/tests/functional/openlp_plugins/songs/test_openlyricsimport.py b/tests/functional/openlp_plugins/songs/test_openlyricsimport.py index 376ef9f7a..ddfb0f543 100644 --- a/tests/functional/openlp_plugins/songs/test_openlyricsimport.py +++ b/tests/functional/openlp_plugins/songs/test_openlyricsimport.py @@ -134,7 +134,7 @@ class TestOpenLyricsImport(TestCase, TestMixin): importer.do_import() # THEN: The xml_to_song() method should have been called - self.assertTrue(importer.open_lyrics.xml_to_song.called) + assert importer.open_lyrics.xml_to_song.called is True def test_process_formatting_tags(self): """ @@ -173,8 +173,8 @@ class TestOpenLyricsImport(TestCase, TestMixin): ol._process_authors(properties_xml, mocked_song) # THEN: add_author should have been called twice - self.assertEquals(mocked_song.method_calls[0][1][1], 'words+music') - self.assertEquals(mocked_song.method_calls[1][1][1], 'words') + assert mocked_song.method_calls[0][1][1] == 'words+music' + assert mocked_song.method_calls[1][1][1] == 'words' def test_process_songbooks(self): """ @@ -192,5 +192,5 @@ class TestOpenLyricsImport(TestCase, TestMixin): ol._process_songbooks(properties_xml, mocked_song) # THEN: add_songbook_entry should have been called twice - self.assertEquals(mocked_song.method_calls[0][1][1], '48') - self.assertEquals(mocked_song.method_calls[1][1][1], '445 A') + assert mocked_song.method_calls[0][1][1] == '48' + assert mocked_song.method_calls[1][1][1] == '445 A' diff --git a/tests/functional/openlp_plugins/songs/test_opensongimport.py b/tests/functional/openlp_plugins/songs/test_opensongimport.py index 290e02af5..d496bffcb 100644 --- a/tests/functional/openlp_plugins/songs/test_opensongimport.py +++ b/tests/functional/openlp_plugins/songs/test_opensongimport.py @@ -87,7 +87,7 @@ class TestOpenSongImport(TestCase): importer = OpenSongImport(mocked_manager, file_paths=[]) # THEN: The importer object should not be None - self.assertIsNotNone(importer, 'Import should not be none') + assert importer is not None, 'Import should not be none' def test_invalid_import_source(self): """ diff --git a/tests/functional/openlp_plugins/songs/test_songbeamerimport.py b/tests/functional/openlp_plugins/songs/test_songbeamerimport.py index 165abd1a9..a97585c6a 100644 --- a/tests/functional/openlp_plugins/songs/test_songbeamerimport.py +++ b/tests/functional/openlp_plugins/songs/test_songbeamerimport.py @@ -99,7 +99,7 @@ class TestSongBeamerImport(TestCase): importer = SongBeamerImport(mocked_manager, file_paths=[]) # THEN: The importer object should not be None - self.assertIsNotNone(importer, 'Import should not be none') + assert importer is not None, 'Import should not be none' def test_invalid_import_source(self): """ @@ -115,10 +115,10 @@ class TestSongBeamerImport(TestCase): self.importer.import_source = source # THEN: do_import should return none and the progress bar maximum should not be set. - self.assertIsNone(self.importer.do_import(), - 'do_import should return None when import_source is not a list') - self.assertEqual(mocked_import_wizard.progress_bar.setMaximum.called, False, - 'setMaxium on import_wizard.progress_bar should not have been called') + assert self.importer.do_import() is None, \ + 'do_import should return None when import_source is not a list' + assert mocked_import_wizard.progress_bar.setMaximum.called is False, \ + 'setMaxium on import_wizard.progress_bar should not have been called' def test_valid_import_source(self): """ @@ -134,8 +134,8 @@ class TestSongBeamerImport(TestCase): # THEN: do_import should return none and the progress bar setMaximum should be called with the length of # import_source. - self.assertIsNone(self.importer.do_import(), - 'do_import should return None when import_source is a list and stop_import_flag is True') + assert self.importer.do_import() is None, \ + 'do_import should return None when import_source is a list and stop_import_flag is True' mocked_import_wizard.progress_bar.setMaximum.assert_called_with(len(self.importer.import_source)) def test_check_verse_marks(self): @@ -149,8 +149,8 @@ class TestSongBeamerImport(TestCase): # WHEN: line is being checked for verse marks result = self.importer.check_verse_marks(line) # THEN: we should get back true and c as self.importer.current_verse_type - self.assertTrue(result, 'Versemark for should be found, value true') - self.assertEqual(self.importer.current_verse_type, 'c', ' should be interpreted as ') + .assert result is True, 'Versemark for should be found, value true' + assert self.importer.current_verse_type == 'c', ' should be interpreted as ' # GIVEN: line with unnumbered verse-type and trailing space line = 'ReFrain ' @@ -158,8 +158,8 @@ class TestSongBeamerImport(TestCase): # WHEN: line is being checked for verse marks result = self.importer.check_verse_marks(line) # THEN: we should get back true and c as self.importer.current_verse_type - self.assertTrue(result, 'Versemark for should be found, value true') - self.assertEqual(self.importer.current_verse_type, 'c', ' should be interpreted as ') + assert result is True, 'Versemark for should be found, value true' + assert self.importer.current_verse_type == 'c', ' should be interpreted as ' # GIVEN: line with numbered verse-type line = 'VersE 1' @@ -167,8 +167,8 @@ class TestSongBeamerImport(TestCase): # WHEN: line is being checked for verse marks result = self.importer.check_verse_marks(line) # THEN: we should get back true and v1 as self.importer.current_verse_type - self.assertTrue(result, 'Versemark for should be found, value true') - self.assertEqual(self.importer.current_verse_type, 'v1', u' should be interpreted as ') + assert result is True, 'Versemark for should be found, value true' + assert self.importer.current_verse_type == 'v1', u' should be interpreted as ' # GIVEN: line with special unnumbered verse-mark (used in Songbeamer to allow usage of non-supported tags) line = '$$M=special' @@ -176,8 +176,8 @@ class TestSongBeamerImport(TestCase): # WHEN: line is being checked for verse marks result = self.importer.check_verse_marks(line) # THEN: we should get back true and o as self.importer.current_verse_type - self.assertTrue(result, 'Versemark for <$$M=special> should be found, value true') - self.assertEqual(self.importer.current_verse_type, 'o', u'<$$M=special> should be interpreted as ') + assert result is True, 'Versemark for <$$M=special> should be found, value true' + assert self.importer.current_verse_type == 'o', u'<$$M=special> should be interpreted as ' # GIVEN: line with song-text with 3 words line = 'Jesus my saviour' @@ -185,9 +185,8 @@ class TestSongBeamerImport(TestCase): # WHEN: line is being checked for verse marks result = self.importer.check_verse_marks(line) # THEN: we should get back false and none as self.importer.current_verse_type - self.assertFalse(result, 'No versemark for should be found, value false') - self.assertIsNone(self.importer.current_verse_type, - ' should be interpreted as none versemark') + assert result is False, 'No versemark for should be found, value false' + assert self.importer.current_verse_type is None, ' should be interpreted as none versemark' # GIVEN: line with song-text with 2 words line = 'Praise him' @@ -195,8 +194,8 @@ class TestSongBeamerImport(TestCase): # WHEN: line is being checked for verse marks result = self.importer.check_verse_marks(line) # THEN: we should get back false and none as self.importer.current_verse_type - self.assertFalse(result, 'No versemark for should be found, value false') - self.assertIsNone(self.importer.current_verse_type, ' should be interpreted as none versemark') + assert result is False, 'No versemark for should be found, value false' + assert self.importer.current_verse_type is None, ' should be interpreted as none versemark' # GIVEN: line with only a space (could occur, nothing regular) line = ' ' @@ -204,8 +203,8 @@ class TestSongBeamerImport(TestCase): # WHEN: line is being checked for verse marks result = self.importer.check_verse_marks(line) # THEN: we should get back false and none as self.importer.current_verse_type - self.assertFalse(result, 'No versemark for < > should be found, value false') - self.assertIsNone(self.importer.current_verse_type, '< > should be interpreted as none versemark') + assert result is False, 'No versemark for < > should be found, value false' + assert self.importer.current_verse_type is None, '< > should be interpreted as none versemark' # GIVEN: blank line (could occur, nothing regular) line = '' @@ -213,8 +212,8 @@ class TestSongBeamerImport(TestCase): # WHEN: line is being checked for verse marks result = self.importer.check_verse_marks(line) # THEN: we should get back false and none as self.importer.current_verse_type - self.assertFalse(result, 'No versemark for <> should be found, value false') - self.assertIsNone(self.importer.current_verse_type, '<> should be interpreted as none versemark') + assert result is False, 'No versemark for <> should be found, value false' + assert self.importer.current_verse_type is None, '<> should be interpreted as none versemark' def test_verse_marks_defined_in_lowercase(self): """ @@ -223,4 +222,4 @@ class TestSongBeamerImport(TestCase): # GIVEN: SongBeamber MarkTypes for tag in SongBeamerTypes.MarkTypes.keys(): # THEN: tag should be defined in lowercase - self.assertEquals(tag, tag.lower(), 'Tags should be defined in lowercase') + assert tag == tag.lower(), 'Tags should be defined in lowercase' diff --git a/tests/functional/openlp_plugins/songs/test_songformat.py b/tests/functional/openlp_plugins/songs/test_songformat.py index 4573613a4..c1e674a03 100644 --- a/tests/functional/openlp_plugins/songs/test_songformat.py +++ b/tests/functional/openlp_plugins/songs/test_songformat.py @@ -39,8 +39,8 @@ class TestSongFormat(TestCase): # GIVEN: The SongFormat class # WHEN: Retrieving the format list # THEN: All SongFormats should be returned - self.assertEquals(len(SongFormat.get_format_list()), len(SongFormat.__attributes__), - "The returned SongFormats don't match the stored ones") + assert len(SongFormat.get_format_list()) == len(SongFormat.__attributes__), \ + "The returned SongFormats don't match the stored ones" def test_get_attributed_no_attributes(self): """ @@ -50,8 +50,8 @@ class TestSongFormat(TestCase): # WHEN: Retrieving all attributes of a SongFormat for song_format in SongFormat.get_format_list(): # THEN: All attributes associated with the SongFormat should be returned - self.assertEquals(SongFormat.get(song_format), SongFormat.__attributes__[song_format], - "The returned attributes don't match the stored ones") + assert SongFormat.get(song_format) == SongFormat.__attributes__[song_format], \ + "The returned attributes don't match the stored ones" def test_get_attributed_single_attribute(self): """ @@ -62,14 +62,14 @@ class TestSongFormat(TestCase): # WHEN: Retrieving an attribute that overrides the default values for attribute in SongFormat.get(song_format).keys(): # THEN: Return the attribute - self.assertEquals(SongFormat.get(song_format, attribute), SongFormat.get(song_format)[attribute], - "The returned attribute doesn't match the stored one") + assert SongFormat.get(song_format, attribute) == SongFormat.get(song_format)[attribute], \ + "The returned attribute doesn't match the stored one" # WHEN: Retrieving an attribute that was not overridden for attribute in SongFormat.__defaults__.keys(): if attribute not in SongFormat.get(song_format).keys(): # THEN: Return the default value - self.assertEquals(SongFormat.get(song_format, attribute), SongFormat.__defaults__[attribute], - "The returned attribute does not match the default values stored") + assert SongFormat.get(song_format, attribute) == SongFormat.__defaults__[attribute], \ + "The returned attribute does not match the default values stored" def test_get_attributed_multiple_attributes(self): """ @@ -79,9 +79,8 @@ class TestSongFormat(TestCase): # WHEN: Retrieving multiple attributes at the same time for song_format in SongFormat.get_format_list(): # THEN: Return all attributes that were specified - self.assertEquals(len(SongFormat.get(song_format, 'canDisable', 'availability')), 2, - "Did not return the correct number of attributes" - " when retrieving multiple attributes at once") + assert len(SongFormat.get(song_format, 'canDisable', 'availability')) == 2, \ + "Did not return the correct number of attributes when retrieving multiple attributes at once" def test_get_format_list_returns_ordered_list(self): """ @@ -91,5 +90,5 @@ class TestSongFormat(TestCase): # GIVEN: The SongFormat class # WHEN: Retrieving all formats # THEN: The returned list should be sorted according to the ordering defined in SongFormat - self.assertEquals(sorted(SongFormat.get_format_list()), SongFormat.get_format_list(), - "The list returned should be sorted according to the ordering in SongFormat") + assert sorted(SongFormat.get_format_list()) == SongFormat.get_format_list(), \ + "The list returned should be sorted according to the ordering in SongFormat" diff --git a/tests/functional/openlp_plugins/songs/test_songselect.py b/tests/functional/openlp_plugins/songs/test_songselect.py index d7124878c..56ce12c70 100644 --- a/tests/functional/openlp_plugins/songs/test_songselect.py +++ b/tests/functional/openlp_plugins/songs/test_songselect.py @@ -610,7 +610,7 @@ class TestSongSelectForm(TestCase, TestMixin): 'Your song has been imported, would you like to import more songs?', defaultButton=QtWidgets.QMessageBox.Yes) mocked_on_back_button_clicked.assert_called_with() - self.assertIsNone(ssform.song) + assert ssform.song is None @patch('openlp.plugins.songs.forms.songselectform.QtWidgets.QMessageBox.question') @patch('openlp.plugins.songs.forms.songselectform.translate') @@ -636,7 +636,7 @@ class TestSongSelectForm(TestCase, TestMixin): 'Your song has been imported, would you like to import more songs?', defaultButton=QtWidgets.QMessageBox.Yes) mocked_done.assert_called_with(QtWidgets.QDialog.Accepted) - self.assertIsNone(ssform.song) + assert ssform.song is None def test_on_back_button_clicked(self): """ @@ -764,8 +764,8 @@ class TestSongSelectForm(TestCase, TestMixin): # THEN: The view button, search box and search button should be enabled mocked_song_select_importer.stop.assert_called_with() - self.assertTrue(ssform.search_button.isEnabled()) - self.assertTrue(ssform.search_combobox.isEnabled()) + assert ssform.search_button.isEnabled() is True + assert ssform.search_combobox.isEnabled() is True @patch('openlp.plugins.songs.forms.songselectform.Settings') @patch('openlp.plugins.songs.forms.songselectform.QtCore.QThread') @@ -782,8 +782,8 @@ class TestSongSelectForm(TestCase, TestMixin): ssform.on_search_button_clicked() # THEN: The search box and search button should be disabled - self.assertFalse(ssform.search_button.isEnabled()) - self.assertFalse(ssform.search_combobox.isEnabled()) + assert ssform.search_button.isEnabled() is False + assert ssform.search_combobox.isEnabled() is False def test_on_search_finished(self): """ @@ -797,8 +797,8 @@ class TestSongSelectForm(TestCase, TestMixin): ssform.on_search_finished() # THEN: The search box and search button should be enabled - self.assertTrue(ssform.search_button.isEnabled()) - self.assertTrue(ssform.search_combobox.isEnabled()) + assert ssform.search_button.isEnabled() is True + assert ssform.search_combobox.isEnabled() is True class TestSongSelectFileImport(SongImportTestHelper): @@ -834,8 +834,8 @@ class TestSearchWorker(TestCase, TestMixin): worker = SearchWorker(importer, search_text) # THEN: The correct values should be set - self.assertIs(importer, worker.importer, 'The importer should be the right object') - self.assertEqual(search_text, worker.search_text, 'The search text should be correct') + assert importer is worker.importer, 'The importer should be the right object' + assert search_text == worker.search_text, 'The search text should be correct' def test_start(self): """ diff --git a/tests/functional/openlp_plugins/songs/test_songshowplusimport.py b/tests/functional/openlp_plugins/songs/test_songshowplusimport.py index 79e8ba593..4c64131b2 100644 --- a/tests/functional/openlp_plugins/songs/test_songshowplusimport.py +++ b/tests/functional/openlp_plugins/songs/test_songshowplusimport.py @@ -73,7 +73,7 @@ class TestSongShowPlusImport(TestCase): importer = SongShowPlusImport(mocked_manager, file_paths=[]) # THEN: The importer object should not be None - self.assertIsNotNone(importer, 'Import should not be none') + assert importer is not None, 'Import should not be none' def test_invalid_import_source(self): """ @@ -92,9 +92,9 @@ class TestSongShowPlusImport(TestCase): importer.import_source = source # THEN: do_import should return none and the progress bar maximum should not be set. - self.assertIsNone(importer.do_import(), 'do_import should return None when import_source is not a list') - self.assertEqual(mocked_import_wizard.progress_bar.setMaximum.called, False, - 'setMaximum on import_wizard.progress_bar should not have been called') + assert importer.do_import() is None, 'do_import should return None when import_source is not a list' + assert mocked_import_wizard.progress_bar.setMaximum.called is False, \ + 'setMaximum on import_wizard.progress_bar should not have been called' def test_valid_import_source(self): """ @@ -113,8 +113,8 @@ class TestSongShowPlusImport(TestCase): # THEN: do_import should return none and the progress bar setMaximum should be called with the length of # import_source. - self.assertIsNone(importer.do_import(), 'do_import should return None when import_source is a list ' - 'and stop_import_flag is True') + assert importer.do_import() is None, \ + 'do_import should return None when import_source is a list and stop_import_flag is True' mocked_import_wizard.progress_bar.setMaximum.assert_called_with(len(importer.import_source)) def test_to_openlp_verse_tag(self): @@ -141,9 +141,9 @@ class TestSongShowPlusImport(TestCase): # THEN: The returned value should should correlate with the input arguments for original_tag, openlp_tag in test_values: - self.assertEqual(importer.to_openlp_verse_tag(original_tag), openlp_tag, - 'SongShowPlusImport.to_openlp_verse_tag should return "%s" when called with "%s"' % - (openlp_tag, original_tag)) + assert importer.to_openlp_verse_tag(original_tag) == openlp_tag, \ + 'SongShowPlusImport.to_openlp_verse_tag should return "%s" when called with "%s"' % \ + (openlp_tag, original_tag) def test_to_openlp_verse_tag_verse_order(self): """ @@ -170,6 +170,6 @@ class TestSongShowPlusImport(TestCase): # THEN: The returned value should should correlate with the input arguments for original_tag, openlp_tag in test_values: - self.assertEqual(importer.to_openlp_verse_tag(original_tag, ignore_unique=True), openlp_tag, - 'SongShowPlusImport.to_openlp_verse_tag should return "%s" when called with "%s"' % - (openlp_tag, original_tag)) + assert importer.to_openlp_verse_tag(original_tag, ignore_unique=True) == openlp_tag, \ + 'SongShowPlusImport.to_openlp_verse_tag should return "%s" when called with "%s"' % \ + (openlp_tag, original_tag) diff --git a/tests/functional/openlp_plugins/songusage/test_songusage.py b/tests/functional/openlp_plugins/songusage/test_songusage.py index 406bd4c0e..6ffe9821e 100644 --- a/tests/functional/openlp_plugins/songusage/test_songusage.py +++ b/tests/functional/openlp_plugins/songusage/test_songusage.py @@ -80,7 +80,7 @@ class TestSongUsage(TestCase): ret = song_usage.check_pre_conditions() # THEN: It should return True - self.assertTrue(ret) + assert ret is True @patch('openlp.plugins.songusage.songusageplugin.Manager') def test_toggle_song_usage_state(self, MockedManager): @@ -96,4 +96,4 @@ class TestSongUsage(TestCase): song_usage.toggle_song_usage_state() # THEN: song_usage_state should have been toogled - self.assertFalse(song_usage.song_usage_active) + assert song_usage.song_usage_active is False