Python MagicMock.assert_any_call方法代码示例

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_any_call [as 别名]
    def db_file_import_test(self):
        """
        Test the actual import of real song database files and check that the imported data is correct.
        """

        # GIVEN: Test files with a mocked out SongImport class, a mocked out "manager", a mocked out "import_wizard",
        #       and mocked out "author", "add_copyright", "add_verse", "finish" methods.
        with patch('openlp.plugins.songs.lib.importers.easyworship.SongImport'), \
                patch('openlp.plugins.songs.lib.importers.easyworship.retrieve_windows_encoding') as \
                mocked_retrieve_windows_encoding:
            mocked_retrieve_windows_encoding.return_value = 'cp1252'
            mocked_manager = MagicMock()
            mocked_import_wizard = MagicMock()
            mocked_add_author = MagicMock()
            mocked_add_verse = MagicMock()
            mocked_finish = MagicMock()
            mocked_title = MagicMock()
            mocked_finish.return_value = True
            importer = EasyWorshipSongImportLogger(mocked_manager)
            importer.import_wizard = mocked_import_wizard
            importer.stop_import_flag = False
            importer.add_author = mocked_add_author
            importer.add_verse = mocked_add_verse
            importer.title = mocked_title
            importer.finish = mocked_finish
            importer.topics = []

            # WHEN: Importing each file
            importer.import_source = os.path.join(TEST_PATH, 'Songs.DB')
            import_result = importer.do_import()

            # 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')
            for song_data in SONG_TEST_DATA:
                title = song_data['title']
                author_calls = song_data['authors']
                song_copyright = song_data['copyright']
                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))
                for author in author_calls:
                    mocked_add_author.assert_any_call(author)
                if song_copyright:
                    self.assertEqual(importer.copyright, song_copyright)
                if ccli_number:
                    self.assertEqual(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))
                mocked_finish.assert_called_with()

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_any_call [as 别名]
    def file_import_test(self):
        """
        Test the actual import of real song files and check that the imported data is correct.
        """

        # GIVEN: Test files with a mocked out SongImport class, a mocked out "manager", a mocked out "import_wizard",
        #       and mocked out "author", "add_copyright", "add_verse", "finish" methods.
        with patch('openlp.plugins.songs.lib.importers.songbeamer.SongImport'):
            for song_file in SONG_TEST_DATA:
                mocked_manager = MagicMock()
                mocked_import_wizard = MagicMock()
                mocked_add_verse = MagicMock()
                mocked_finish = MagicMock()
                mocked_finish.return_value = True
                importer = SongBeamerImport(mocked_manager, filenames=[])
                importer.import_wizard = mocked_import_wizard
                importer.stop_import_flag = False
                importer.add_verse = mocked_add_verse
                importer.finish = mocked_finish

                # WHEN: Importing each file
                importer.import_source = [os.path.join(TEST_PATH, song_file)]
                title = SONG_TEST_DATA[song_file]['title']
                add_verse_calls = SONG_TEST_DATA[song_file]['verses']
                song_book_name = SONG_TEST_DATA[song_file]['song_book_name']
                song_number = SONG_TEST_DATA[song_file]['song_number']
                song_authors = SONG_TEST_DATA[song_file]['authors']

                # THEN: do_import should return none, the song data should be as expected, and finish should have been
                #       called.
                self.assertIsNone(importer.do_import(), 'do_import should return None when it has completed')
                self.assertEqual(importer.title, title, 'title for %s should be "%s"' % (song_file, title))
                for verse_text, verse_tag in add_verse_calls:
                    mocked_add_verse.assert_any_call(verse_text, verse_tag)
                if song_book_name:
                    self.assertEqual(importer.song_book_name, song_book_name,
                                     'song_book_name for %s should be "%s"' % (song_file, song_book_name))
                if song_number:
                    self.assertEqual(importer.song_number, song_number,
                                     'song_number for %s should be %s' % (song_file, song_number))
                if song_authors:
                    for author in importer.authors:
                        self.assertIn(author, song_authors)
                mocked_finish.assert_called_with()

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_any_call [as 别名]
    def song_import_test(self):
        """
        Test that a simulated WorshipCenter Pro recordset is imported correctly
        """
        # GIVEN: A mocked out SongImport class, a mocked out pyodbc module with a simulated recordset, a mocked out
        #       translate method,  a mocked "manager", add_verse method & mocked_finish method.
        with patch('openlp.plugins.songs.lib.importers.worshipcenterpro.SongImport'), \
                patch('openlp.plugins.songs.lib.importers.worshipcenterpro.pyodbc') as mocked_pyodbc, \
                patch('openlp.plugins.songs.lib.importers.worshipcenterpro.translate') as mocked_translate:
            mocked_manager = MagicMock()
            mocked_import_wizard = MagicMock()
            mocked_add_verse = MagicMock()
            mocked_finish = MagicMock()
            mocked_pyodbc.connect().cursor().fetchall.return_value = RECORDSET_TEST_DATA
            mocked_translate.return_value = 'Translated Text'
            importer = WorshipCenterProImportLogger(mocked_manager)
            importer.import_source = 'import_source'
            importer.import_wizard = mocked_import_wizard
            importer.add_verse = mocked_add_verse
            importer.stop_import_flag = False
            importer.finish = mocked_finish

            # WHEN: Calling the do_import method
            return_value = importer.do_import()

            # THEN: do_import should return None, and pyodbc, import_wizard, importer.title and add_verse are called
            # with known calls
            self.assertIsNone(return_value, 'do_import should return None when pyodbc raises an exception.')
            mocked_pyodbc.connect.assert_called_with('DRIVER={Microsoft Access Driver (*.mdb)};DBQ=import_source')
            mocked_pyodbc.connect().cursor.assert_any_call()
            mocked_pyodbc.connect().cursor().execute.assert_called_with('SELECT ID, Field, Value FROM __SONGDATA')
            mocked_pyodbc.connect().cursor().fetchall.assert_any_call()
            mocked_import_wizard.progress_bar.setMaximum.assert_called_with(2)
            add_verse_call_count = 0
            for song_data in SONG_TEST_DATA:
                title_value = song_data['title']
                self.assertIn(title_value, importer._title_assignment_list,
                              'title should have been set to %s' % title_value)
                verse_calls = song_data['verses']
                add_verse_call_count += len(verse_calls)
                for call in verse_calls:
                    mocked_add_verse.assert_any_call(call)
            self.assertEqual(mocked_add_verse.call_count, add_verse_call_count,
                             'Incorrect number of calls made to add_verse')

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_any_call [as 别名]
    def ews_file_import_test(self):
        """
        Test the actual import of song from ews file and check that the imported data is correct.
        """

        # GIVEN: Test files with a mocked out SongImport class, a mocked out "manager", a mocked out "import_wizard",
        #       and mocked out "author", "add_copyright", "add_verse", "finish" methods.
        with patch('openlp.plugins.songs.lib.importers.easyworship.SongImport'), \
                patch('openlp.plugins.songs.lib.importers.easyworship.retrieve_windows_encoding') \
                as mocked_retrieve_windows_encoding:
            mocked_retrieve_windows_encoding.return_value = 'cp1252'
            mocked_manager = MagicMock()
            mocked_import_wizard = MagicMock()
            mocked_add_author = MagicMock()
            mocked_add_verse = MagicMock()
            mocked_finish = MagicMock()
            mocked_title = MagicMock()
            mocked_finish.return_value = True
            importer = EasyWorshipSongImportLogger(mocked_manager)
            importer.import_wizard = mocked_import_wizard
            importer.stop_import_flag = False
            importer.add_author = mocked_add_author
            importer.add_verse = mocked_add_verse
            importer.title = mocked_title
            importer.finish = mocked_finish
            importer.topics = []

            # WHEN: Importing ews file
            importer.import_source = os.path.join(TEST_PATH, 'test1.ews')
            import_result = importer.do_import()

            # 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)
            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)
            mocked_finish.assert_called_with()