Python MagicMock.assert_called_with方法代码示例

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_called_with [as 别名]
    def pyodbc_exception_test(self):
        """
        Test that exceptions raised by pyodbc are handled
        """
        # GIVEN: A mocked out SongImport class, a mocked out pyodbc module, a mocked out translate method,
        #       a mocked "manager" and a mocked out log_error method.
        with patch('openlp.plugins.songs.lib.importers.worshipcenterpro.SongImport'), \
                patch('openlp.plugins.songs.lib.importers.worshipcenterpro.pyodbc.connect') as mocked_pyodbc_connect, \
                patch('openlp.plugins.songs.lib.importers.worshipcenterpro.translate') as mocked_translate:
            mocked_manager = MagicMock()
            mocked_log_error = MagicMock()
            mocked_translate.return_value = 'Translated Text'
            importer = WorshipCenterProImport(mocked_manager, filenames=[])
            importer.log_error = mocked_log_error
            importer.import_source = 'import_source'
            pyodbc_errors = [pyodbc.DatabaseError, pyodbc.IntegrityError, pyodbc.InternalError, pyodbc.OperationalError]
            mocked_pyodbc_connect.side_effect = pyodbc_errors

            # WHEN: Calling the do_import method
            for effect in pyodbc_errors:
                return_value = importer.do_import()

                # THEN: do_import should return None, and pyodbc, translate & log_error 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_translate.assert_called_with('SongsPlugin.WorshipCenterProImport',
                                                    'Unable to connect the WorshipCenter Pro database.')
                mocked_log_error.assert_called_with('import_source', 'Translated Text')

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_called_with [as 别名]
    def test_reject_with_inactive_items(self):
        """
        Test that the reject() method works correctly when some of the plugins are inactive
        """
        # GIVEN: A visible general tab and an invisible theme tab in a Settings Form
        settings_form = SettingsForm(None)
        general_tab = QtWidgets.QWidget(None)
        general_tab.tab_title = 'mock-general'
        general_tab.tab_title_visible = 'Mock General'
        general_tab.icon_path = ':/icon/openlp-logo.svg'
        mocked_general_cancel = MagicMock()
        general_tab.cancel = mocked_general_cancel
        settings_form.insert_tab(general_tab, is_visible=True)
        themes_tab = QtWidgets.QWidget(None)
        themes_tab.tab_title = 'mock-themes'
        themes_tab.tab_title_visible = 'Mock Themes'
        themes_tab.icon_path = ':/icon/openlp-logo.svg'
        mocked_theme_cancel = MagicMock()
        themes_tab.cancel = mocked_theme_cancel
        settings_form.insert_tab(themes_tab, is_visible=False)

        # WHEN: The reject() method is called
        settings_form.reject()

        # THEN: The general tab's cancel() method should have been called, but not the themes tab
        mocked_general_cancel.assert_called_with()
        self.assertEqual(0, mocked_theme_cancel.call_count, 'The Themes tab\'s cancel() should not have been called')

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_called_with [as 别名]
    def accept_with_inactive_plugins_test(self):
        """
        Test that the accept() method works correctly when some of the plugins are inactive
        """
        # GIVEN: A visible general tab and an invisible theme tab in a Settings Form
        settings_form = SettingsForm(None)
        general_tab = QtGui.QWidget(None)
        general_tab.tab_title = 'mock-general'
        general_tab.tab_title_visible = 'Mock General'
        general_tab.icon_path = ':/icon/openlp-logo-16x16.png'
        mocked_general_save = MagicMock()
        general_tab.save = mocked_general_save
        settings_form.insert_tab(general_tab, is_visible=True)
        themes_tab = QtGui.QWidget(None)
        themes_tab.tab_title = 'mock-themes'
        themes_tab.tab_title_visible = 'Mock Themes'
        themes_tab.icon_path = ':/icon/openlp-logo-16x16.png'
        mocked_theme_save = MagicMock()
        themes_tab.save = mocked_theme_save
        settings_form.insert_tab(themes_tab, is_visible=False)

        # WHEN: The accept() method is called
        settings_form.accept()

        # THEN: The general tab's save() method should have been called, but not the themes tab
        mocked_general_save.assert_called_with()
        self.assertEqual(0, mocked_theme_save.call_count, 'The Themes tab\'s save() should not have been called')

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_called_with [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_called_with [as 别名]
    def test_translate(self):
        """
        Test the translate() function
        """
        # GIVEN: A string to translate and a mocked Qt translate function
        context = 'OpenLP.Tests'
        text = 'Untranslated string'
        comment = 'A comment'
        mocked_translate = MagicMock(return_value='Translated string')

        # WHEN: we call the translate function
        result = translate(context, text, comment, mocked_translate)

        # THEN: the translated string should be returned, and the mocked function should have been called
        mocked_translate.assert_called_with(context, text, comment)
        self.assertEqual('Translated string', result, 'The translated string should have been returned')

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_called_with [as 别名]
    def test_get_song_page_raises_exception(self, mocked_build_opener):
        """
        Test that when BeautifulSoup gets a bad song page the get_song() method returns None
        """
        # GIVEN: A bunch of mocked out stuff and an importer object
        mocked_opener = MagicMock()
        mocked_build_opener.return_value = mocked_opener
        mocked_opener.open.read.side_effect = URLError('[Errno -2] Name or service not known')
        mocked_callback = MagicMock()
        importer = SongSelectImport(None)

        # WHEN: get_song is called
        result = importer.get_song({'link': 'link'}, callback=mocked_callback)

        # THEN: The callback should have been called once and None should be returned
        mocked_callback.assert_called_with()
        self.assertIsNone(result, 'The get_song() method should have returned None')

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_called_with [as 别名]
    def receive_spin_delay_test(self, MockedSettings):
        """
        Test that the spin box is updated accordingly after a call to receive_spin_delay()
        """
        # GIVEN: A new SlideController instance.
        mocked_value = MagicMock(return_value=1)
        MockedSettings.return_value = MagicMock(value=mocked_value)
        mocked_delay_spin_box = MagicMock()
        slide_controller = SlideController(None)
        slide_controller.delay_spin_box = mocked_delay_spin_box

        # WHEN: The receive_spin_delay() method is called
        slide_controller.receive_spin_delay()

        # THEN: The Settings()value() and delay_spin_box.setValue() methods should have been called correctly
        mocked_value.assert_called_with('core/loop delay')
        mocked_delay_spin_box.setValue.assert_called_with(1)

# 需要导入模块: from tests.functional import MagicMock [as 别名]
# 或者: from tests.functional.MagicMock import assert_called_with [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_called_with [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()