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

Pathlib refactors and test fixes

This commit is contained in:
Phill Ridout 2017-11-18 11:23:15 +00:00
parent 71eaccb547
commit 9196db5af0
21 changed files with 143 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
openlp/core/api/deploy.py
View File

@ -22,7 +22,6 @@
"""
Download and "install" the remote web client
"""
import os
from zipfile import ZipFile
from openlp.core.common.applocation import AppLocation
@ -30,18 +29,18 @@ from openlp.core.common.registry import Registry
from openlp.core.common.httputils import url_get_file, get_web_page, get_url_file_size
def deploy_zipfile(app_root, zip_name):
def deploy_zipfile(app_root_path, zip_name):
"""
Process the downloaded zip file and add to the correct directory
:param zip_name: the zip file to be processed
:param app_root: the directory where the zip get expanded to
:param str zip_name: the zip file name to be processed
:param openlp.core.common.path.Path app_root_path: The directory to expand the zip to
:return: None
"""
zip_file = os.path.join(app_root, zip_name)
web_zip = ZipFile(zip_file)
web_zip.extractall(app_root)
zip_path = app_root_path / zip_name
web_zip = ZipFile(str(zip_path))
web_zip.extractall(str(app_root_path))
def download_sha256():
@ -67,4 +66,4 @@ def download_and_check(callback=None):
if url_get_file(callback, 'https://get.openlp.org/webclient/site.zip',
AppLocation.get_section_data_path('remotes') / 'site.zip',
sha256=sha256):
deploy_zipfile(str(AppLocation.get_section_data_path('remotes')), 'site.zip')
deploy_zipfile(AppLocation.get_section_data_path('remotes'), 'site.zip')

11
openlp/core/api/endpoint/controller.py
View File

@ -28,6 +28,7 @@ import json
from openlp.core.api.http.endpoint import Endpoint
from openlp.core.api.http import requires_auth
from openlp.core.common.applocation import AppLocation
from openlp.core.common.path import Path
from openlp.core.common.registry import Registry
from openlp.core.common.settings import Settings
from openlp.core.lib import ItemCapabilities, create_thumb
@ -66,12 +67,12 @@ def controller_text(request):
elif current_item.is_image() and not frame.get('image', '') and Settings().value('api/thumbnails'):
item['tag'] = str(index + 1)
thumbnail_path = os.path.join('images', 'thumbnails', frame['title'])
full_thumbnail_path = str(AppLocation.get_data_path() / thumbnail_path)
full_thumbnail_path = AppLocation.get_data_path() / thumbnail_path
# Create thumbnail if it doesn't exists
if not os.path.exists(full_thumbnail_path):
create_thumb(current_item.get_frame_path(index), full_thumbnail_path, False)
Registry().get('image_manager').add_image(full_thumbnail_path, frame['title'], None, 88, 88)
item['img'] = urllib.request.pathname2url(os.path.sep + thumbnail_path)
if not full_thumbnail_path.exists():
create_thumb(Path(current_item.get_frame_path(index)), full_thumbnail_path, False)
Registry().get('image_manager').add_image(str(full_thumbnail_path), frame['title'], None, 88, 88)
item['img'] = urllib.request.pathname2url(os.path.sep + str(thumbnail_path))
item['text'] = str(frame['title'])
item['html'] = str(frame['title'])
else:

15
openlp/core/api/endpoint/pluginhelpers.py
View File

@ -19,7 +19,6 @@
# with this program; if not, write to the Free Software Foundation, Inc., 59 #
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
import os
import json
import re
import urllib
@ -103,7 +102,7 @@ def display_thumbnails(request, controller_name, log, dimensions, file_name, sli
:param controller_name: which controller is requesting the image
:param log: the logger object
:param dimensions: the image size eg 88x88
:param file_name: the file name of the image
:param str file_name: the file name of the image
:param slide: the individual image name
:return:
"""
@ -124,12 +123,10 @@ def display_thumbnails(request, controller_name, log, dimensions, file_name, sli
if controller_name and file_name:
file_name = urllib.parse.unquote(file_name)
if '..' not in file_name: # no hacking please
full_path = AppLocation.get_section_data_path(controller_name) / 'thumbnails' / file_name
if slide:
full_path = str(AppLocation.get_section_data_path(controller_name) / 'thumbnails' / file_name / slide)
else:
full_path = str(AppLocation.get_section_data_path(controller_name) / 'thumbnails' / file_name)
if os.path.exists(full_path):
path, just_file_name = os.path.split(full_path)
Registry().get('image_manager').add_image(full_path, just_file_name, None, width, height)
image = Registry().get('image_manager').get_image(full_path, just_file_name, width, height)
full_path = full_path / slide
if full_path.exists():
Registry().get('image_manager').add_image(full_path, full_path.name, None, width, height)
image = Registry().get('image_manager').get_image(full_path, full_path.name, width, height)
return Response(body=image_to_byte(image, False), status=200, content_type='image/png', charset='utf8')

12
openlp/core/api/http/endpoint.py
View File

@ -22,8 +22,6 @@
"""
The Endpoint class, which provides plugins with a way to serve their own portion of the API
"""
import os
from mako.template import Template
from openlp.core.common.applocation import AppLocation
@ -67,13 +65,17 @@ class Endpoint(object):
def render_template(self, filename, **kwargs):
"""
Render a mako template
:param str filename: The file name of the template to render.
:return: The rendered template object.
:rtype: mako.template.Template
"""
root = str(AppLocation.get_section_data_path('remotes'))
root_path = AppLocation.get_section_data_path('remotes')
if not self.template_dir:
raise Exception('No template directory specified')
path = os.path.join(root, self.template_dir, filename)
path = root_path / self.template_dir / filename
if self.static_dir:
kwargs['static_url'] = '/{prefix}/static'.format(prefix=self.url_prefix)
kwargs['static_url'] = kwargs['static_url'].replace('//', '/')
kwargs['assets_url'] = '/assets'
return Template(filename=path, input_encoding='utf-8').render(**kwargs)
return Template(filename=str(path), input_encoding='utf-8').render(**kwargs)

8
openlp/core/api/http/wsgiapp.py
View File

@ -25,7 +25,6 @@ App stuff
"""
import json
import logging
import os
import re
from webob import Request, Response
@ -138,12 +137,11 @@ class WSGIApplication(object):
Add a static directory as a route
"""
if route not in self.static_routes:
root = str(AppLocation.get_section_data_path('remotes'))
static_path = os.path.abspath(os.path.join(root, static_dir))
if not os.path.exists(static_path):
static_path = AppLocation.get_section_data_path('remotes') / static_dir
if not static_path.exists():
log.error('Static path "%s" does not exist. Skipping creating static route/', static_path)
return
self.static_routes[route] = DirectoryApp(static_path)
self.static_routes[route] = DirectoryApp(str(static_path.resolve()))
def dispatch(self, request):
"""

3
openlp/core/common/path.py
View File

@ -69,6 +69,9 @@ class Path(PathVariant):
path = path.relative_to(base_path)
return {'__Path__': path.parts}
def rmtree(self, *args, **kwargs):
shutil.rmtree(str(self), *args, **kwargs)
def replace_params(args, kwargs, params):
"""

4
openlp/core/display/renderer.py
View File

@ -198,6 +198,7 @@ class Renderer(RegistryBase, LogMixin, RegistryProperties):
:param theme_data: The theme to generated a preview for.
:param force_page: Flag to tell message lines per page need to be generated.
:rtype: QtGui.QPixmap
"""
# save value for use in format_slide
self.force_page = force_page
@ -222,8 +223,7 @@ class Renderer(RegistryBase, LogMixin, RegistryProperties):
self.display.build_html(service_item)
raw_html = service_item.get_rendered_frame(0)
self.display.text(raw_html, False)
preview = self.display.preview()
return preview
return self.display.preview()
self.force_page = False
def format_slide(self, text, item):

9
openlp/core/lib/__init__.py
View File

@ -179,8 +179,9 @@ def create_thumb(image_path, thumb_path, return_icon=True, size=None):
height of 88 is used.
:return: The final icon.
"""
ext = os.path.splitext(thumb_path)[1].lower()
reader = QtGui.QImageReader(image_path)
# TODO: To path object
thumb_path = Path(thumb_path)
reader = QtGui.QImageReader(str(image_path))
if size is None:
# No size given; use default height of 88
if reader.size().isEmpty():
@ -207,10 +208,10 @@ def create_thumb(image_path, thumb_path, return_icon=True, size=None):
# Invalid; use default height of 88
reader.setScaledSize(QtCore.QSize(int(ratio * 88), 88))
thumb = reader.read()
thumb.save(thumb_path, ext[1:])
thumb.save(str(thumb_path), thumb_path.suffix[1:].lower())
if not return_icon:
return
if os.path.exists(thumb_path):
if thumb_path.exists():
return build_icon(thumb_path)
# Fallback for files with animation support.
return build_icon(image_path)

17
openlp/core/lib/plugin.py
View File

@ -139,10 +139,6 @@ class Plugin(QtCore.QObject, RegistryProperties):
self.text_strings = {}
self.set_plugin_text_strings()
self.name_strings = self.text_strings[StringContent.Name]
if version:
self.version = version
else:
self.version = get_version()['version']
self.settings_section = self.name
self.icon = None
self.media_item_class = media_item_class
@ -162,6 +158,19 @@ class Plugin(QtCore.QObject, RegistryProperties):
Settings.extend_default_settings(default_settings)
Registry().register_function('{name}_add_service_item'.format(name=self.name), self.process_add_service_event)
Registry().register_function('{name}_config_updated'.format(name=self.name), self.config_update)
self._setup(version)
def _setup(self, version):
"""
Run some initial setup. This method is separate from __init__ in order to mock it out in tests.
:param version: Defaults to *None*, which means that the same version number is used as OpenLP's version number.
:rtype: None
"""
if version:
self.version = version
else:
self.version = get_version()['version']
def check_pre_conditions(self):
"""

2
openlp/core/ui/maindisplay.py
View File

@ -398,6 +398,8 @@ class MainDisplay(Display, LogMixin, RegistryProperties):
def preview(self):
"""
Generates a preview of the image displayed.
:rtype: QtGui.QPixmap
"""
was_visible = self.isVisible()
self.application.process_events()

7
openlp/core/ui/mainwindow.py
View File

@ -296,10 +296,9 @@ class Ui_MainWindow(object):
# Give QT Extra Hint that this is an About Menu Item
self.about_item.setMenuRole(QtWidgets.QAction.AboutRole)
if is_win():
self.local_help_file = os.path.join(str(AppLocation.get_directory(AppLocation.AppDir)), 'OpenLP.chm')
self.local_help_file = AppLocation.get_directory(AppLocation.AppDir) / 'OpenLP.chm'
elif is_macosx():
self.local_help_file = os.path.join(str(AppLocation.get_directory(AppLocation.AppDir)),
'..', 'Resources', 'OpenLP.help')
self.local_help_file = AppLocation.get_directory(AppLocation.AppDir) / '..' / 'Resources' / 'OpenLP.help'
self.user_manual_item = create_action(main_window, 'userManualItem', icon=':/system/system_help_contents.png',
can_shortcuts=True, category=UiStrings().Help,
triggers=self.on_help_clicked)
@ -760,7 +759,7 @@ class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow, RegistryProperties):
Use the Online manual in other cases. (Linux)
"""
if is_macosx() or is_win():
QtGui.QDesktopServices.openUrl(QtCore.QUrl.fromLocalFile(self.local_help_file))
QtGui.QDesktopServices.openUrl(QtCore.QUrl.fromLocalFile(str(self.local_help_file)))
else:
import webbrowser
webbrowser.open_new('http://manual.openlp.org/')

13
openlp/core/ui/thememanager.py
View File

@ -497,12 +497,12 @@ class ThemeManager(QtWidgets.QWidget, RegistryBase, Ui_ThemeManager, LogMixin, R
name = translate('OpenLP.ThemeManager', '{name} (default)').format(name=text_name)
else:
name = text_name
thumb = self.thumb_path / '{name}.png'.format(name=text_name)
thumb_path = self.thumb_path / '{name}.png'.format(name=text_name)
item_name = QtWidgets.QListWidgetItem(name)
if validate_thumb(theme_path, thumb):
icon = build_icon(thumb)
if validate_thumb(theme_path, thumb_path):
icon = build_icon(thumb_path)
else:
icon = create_thumb(str(theme_path), str(thumb))
icon = create_thumb(theme_path, thumb_path)
item_name.setIcon(icon)
item_name.setData(QtCore.Qt.UserRole, text_name)
self.theme_list_widget.addItem(item_name)
@ -692,7 +692,7 @@ class ThemeManager(QtWidgets.QWidget, RegistryBase, Ui_ThemeManager, LogMixin, R
sample_path_name.unlink()
frame.save(str(sample_path_name), 'png')
thumb_path = self.thumb_path / '{name}.png'.format(name=theme_name)
create_thumb(str(sample_path_name), str(thumb_path), False)
create_thumb(sample_path_name, thumb_path, False)
def update_preview_images(self):
"""
@ -710,7 +710,8 @@ class ThemeManager(QtWidgets.QWidget, RegistryBase, Ui_ThemeManager, LogMixin, R
Call the renderer to build a Sample Image
:param theme_data: The theme to generated a preview for.
:param force_page: Flag to tell message lines per page need to be generated.
:param force_page: Flag to tell message lines per page need to be generated.7
:rtype: QtGui.QPixmap
"""
return self.renderer.generate_preview(theme_data, force_page)

11
openlp/core/version.py
View File

@ -23,7 +23,6 @@
The :mod:`openlp.core.version` module downloads the version details for OpenLP.
"""
import logging
import os
import platform
import sys
import time
@ -176,18 +175,12 @@ def get_version():
full_version = '{tag}-bzr{tree}'.format(tag=tag_version.strip(), tree=tree_revision.strip())
else:
# We're not running the development version, let's use the file.
file_path = str(AppLocation.get_directory(AppLocation.VersionDir))
file_path = os.path.join(file_path, '.version')
version_file = None
file_path = AppLocation.get_directory(AppLocation.VersionDir) / '.version'
try:
version_file = open(file_path, 'r')
full_version = str(version_file.read()).rstrip()
full_version = file_path.read_text().rstrip()
except OSError:
log.exception('Error in version file.')
full_version = '0.0.0-bzr000'
finally:
if version_file:
version_file.close()
bits = full_version.split('-')
APPLICATION_VERSION = {
'full': full_version,

2
openlp/plugins/images/lib/mediaitem.py
View File

@ -377,7 +377,7 @@ class ImageMediaItem(MediaManagerItem):
if validate_thumb(image.file_path, thumbnail_path):
icon = build_icon(thumbnail_path)
else:
icon = create_thumb(str(image.file_path), str(thumbnail_path))
icon = create_thumb(image.file_path,thumbnail_path)
item_name = QtWidgets.QTreeWidgetItem([file_name])
item_name.setText(0, file_name)
item_name.setIcon(0, icon)

4
openlp/plugins/presentations/lib/mediaitem.py
View File

@ -198,10 +198,10 @@ class PresentationMediaItem(MediaManagerItem):
if not (preview_path and preview_path.exists()):
icon = build_icon(':/general/general_delete.png')
else:
if validate_thumb(Path(preview_path), Path(thumbnail_path)):
if validate_thumb(preview_path, thumbnail_path):
icon = build_icon(thumbnail_path)
else:
icon = create_thumb(str(preview_path), str(thumbnail_path))
icon = create_thumb(preview_path, thumbnail_path)
else:
if initial_load:
icon = build_icon(':/general/general_delete.png')

2
openlp/plugins/presentations/lib/presentationcontroller.py
View File

@ -267,7 +267,7 @@ class PresentationDocument(object):
return
if image_path.is_file():
thumb_path = self.get_thumbnail_path(index, False)
create_thumb(str(image_path), str(thumb_path), False, QtCore.QSize(-1, 360))
create_thumb(image_path, thumb_path, False, QtCore.QSize(-1, 360))
def get_thumbnail_path(self, slide_no, check_exists=False):
"""

26
tests/functional/openlp_core/api/test_deploy.py
View File

@ -19,15 +19,13 @@
# with this program; if not, write to the Free Software Foundation, Inc., 59 #
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
import os
import shutil
from tempfile import mkdtemp
from unittest import TestCase
from openlp.core.api.deploy import deploy_zipfile
from openlp.core.common.path import Path, copyfile
TEST_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', 'resources'))
TEST_PATH = (Path(__file__).parent / '..' / '..' / '..' / 'resources').resolve()
class TestRemoteDeploy(TestCase):
@ -39,25 +37,25 @@ class TestRemoteDeploy(TestCase):
"""
Setup for tests
"""
self.app_root = mkdtemp()
self.app_root_path = Path(mkdtemp())
def tearDown(self):
"""
Clean up after tests
"""
shutil.rmtree(self.app_root)
self.app_root_path.rmtree()
def test_deploy_zipfile(self):
"""
Remote Deploy tests - test the dummy zip file is processed correctly
"""
# GIVEN: A new downloaded zip file
aa = TEST_PATH
zip_file = os.path.join(TEST_PATH, 'remotes', 'site.zip')
app_root = os.path.join(self.app_root, 'site.zip')
shutil.copyfile(zip_file, app_root)
# WHEN: I process the zipfile
deploy_zipfile(self.app_root, 'site.zip')
zip_path = TEST_PATH / 'remotes' / 'site.zip'
app_root_path = self.app_root_path / 'site.zip'
copyfile(zip_path, app_root_path)
# THEN test if www directory has been created
self.assertTrue(os.path.isdir(os.path.join(self.app_root, 'www')), 'We should have a www directory')
# WHEN: I process the zipfile
deploy_zipfile(self.app_root_path, 'site.zip')
# THEN: test if www directory has been created
self.assertTrue((self.app_root_path / 'www').is_dir(), 'We should have a www directory')

86
tests/functional/openlp_core/lib/test_lib.py
View File

@ -274,32 +274,32 @@ class TestLib(TestCase):
Test the create_thumb() function with a given size.
"""
# GIVEN: An image to create a thumb of.
image_path = os.path.join(TEST_PATH, 'church.jpg')
thumb_path = os.path.join(TEST_PATH, 'church_thumb.jpg')
image_path = Path(TEST_PATH, 'church.jpg')
thumb_path = Path(TEST_PATH, 'church_thumb.jpg')
thumb_size = QtCore.QSize(10, 20)
# Remove the thumb so that the test actually tests if the thumb will be created. Maybe it was not deleted in the
# last test.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
# Only continue when the thumb does not exist.
self.assertFalse(os.path.exists(thumb_path), 'Test was not run, because the thumb already exists.')
self.assertFalse(thumb_path.exists(), 'Test was not run, because the thumb already exists.')
# WHEN: Create the thumb.
icon = create_thumb(image_path, thumb_path, size=thumb_size)
# THEN: Check if the thumb was created and scaled to the given size.
self.assertTrue(os.path.exists(thumb_path), 'Test was not ran, because the thumb already exists')
self.assertTrue(thumb_path.exists(), 'Test was not ran, because the thumb already exists')
self.assertIsInstance(icon, QtGui.QIcon, 'The icon should be a QIcon')
self.assertFalse(icon.isNull(), 'The icon should not be null')
self.assertEqual(thumb_size, QtGui.QImageReader(thumb_path).size(), 'The thumb should have the given size')
self.assertEqual(thumb_size, QtGui.QImageReader(str(thumb_path)).size(), 'The thumb should have the given size')
# Remove the thumb so that the test actually tests if the thumb will be created.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
@ -308,14 +308,14 @@ class TestLib(TestCase):
Test the create_thumb() function with no size specified.
"""
# GIVEN: An image to create a thumb of.
image_path = os.path.join(TEST_PATH, 'church.jpg')
thumb_path = os.path.join(TEST_PATH, 'church_thumb.jpg')
image_path = Path(TEST_PATH, 'church.jpg')
thumb_path = Path(TEST_PATH, 'church_thumb.jpg')
expected_size = QtCore.QSize(63, 88)
# Remove the thumb so that the test actually tests if the thumb will be created. Maybe it was not deleted in the
# last test.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
@ -326,14 +326,15 @@ class TestLib(TestCase):
icon = create_thumb(image_path, thumb_path)
# THEN: Check if the thumb was created, retaining its aspect ratio.
self.assertTrue(os.path.exists(thumb_path), 'Test was not ran, because the thumb already exists')
self.assertTrue(thumb_path.exists(), 'Test was not ran, because the thumb already exists')
self.assertIsInstance(icon, QtGui.QIcon, 'The icon should be a QIcon')
self.assertFalse(icon.isNull(), 'The icon should not be null')
self.assertEqual(expected_size, QtGui.QImageReader(thumb_path).size(), 'The thumb should have the given size')
self.assertEqual(expected_size, QtGui.QImageReader(str(thumb_path)).size(),
'The thumb should have the given size')
# Remove the thumb so that the test actually tests if the thumb will be created.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
@ -342,33 +343,34 @@ class TestLib(TestCase):
Test the create_thumb() function with invalid size specified.
"""
# GIVEN: An image to create a thumb of.
image_path = os.path.join(TEST_PATH, 'church.jpg')
thumb_path = os.path.join(TEST_PATH, 'church_thumb.jpg')
image_path = Path(TEST_PATH, 'church.jpg')
thumb_path = Path(TEST_PATH, 'church_thumb.jpg')
thumb_size = QtCore.QSize(-1, -1)
expected_size = QtCore.QSize(63, 88)
# Remove the thumb so that the test actually tests if the thumb will be created. Maybe it was not deleted in the
# last test.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
# Only continue when the thumb does not exist.
self.assertFalse(os.path.exists(thumb_path), 'Test was not run, because the thumb already exists.')
self.assertFalse(thumb_path.exists(), 'Test was not run, because the thumb already exists.')
# WHEN: Create the thumb.
icon = create_thumb(image_path, thumb_path, size=thumb_size)
# THEN: Check if the thumb was created, retaining its aspect ratio.
self.assertTrue(os.path.exists(thumb_path), 'Test was not ran, because the thumb already exists')
self.assertTrue(thumb_path.exists(), 'Test was not ran, because the thumb already exists')
self.assertIsInstance(icon, QtGui.QIcon, 'The icon should be a QIcon')
self.assertFalse(icon.isNull(), 'The icon should not be null')
self.assertEqual(expected_size, QtGui.QImageReader(thumb_path).size(), 'The thumb should have the given size')
self.assertEqual(expected_size, QtGui.QImageReader(str(thumb_path)).size(),
'The thumb should have the given size')
# Remove the thumb so that the test actually tests if the thumb will be created.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
@ -377,33 +379,33 @@ class TestLib(TestCase):
Test the create_thumb() function with a size of only width specified.
"""
# GIVEN: An image to create a thumb of.
image_path = os.path.join(TEST_PATH, 'church.jpg')
thumb_path = os.path.join(TEST_PATH, 'church_thumb.jpg')
image_path = Path(TEST_PATH, 'church.jpg')
thumb_path = Path(TEST_PATH, 'church_thumb.jpg')
thumb_size = QtCore.QSize(100, -1)
expected_size = QtCore.QSize(100, 137)
# Remove the thumb so that the test actually tests if the thumb will be created. Maybe it was not deleted in the
# last test.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
# Only continue when the thumb does not exist.
self.assertFalse(os.path.exists(thumb_path), 'Test was not run, because the thumb already exists.')
self.assertFalse(thumb_path.exists(), 'Test was not run, because the thumb already exists.')
# WHEN: Create the thumb.
icon = create_thumb(image_path, thumb_path, size=thumb_size)
# THEN: Check if the thumb was created, retaining its aspect ratio.
self.assertTrue(os.path.exists(thumb_path), 'Test was not ran, because the thumb already exists')
self.assertTrue(thumb_path.exists(), 'Test was not ran, because the thumb already exists')
self.assertIsInstance(icon, QtGui.QIcon, 'The icon should be a QIcon')
self.assertFalse(icon.isNull(), 'The icon should not be null')
self.assertEqual(expected_size, QtGui.QImageReader(thumb_path).size(), 'The thumb should have the given size')
self.assertEqual(expected_size, QtGui.QImageReader(str(thumb_path)).size(), 'The thumb should have the given size')
# Remove the thumb so that the test actually tests if the thumb will be created.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
@ -412,33 +414,33 @@ class TestLib(TestCase):
Test the create_thumb() function with a size of only height specified.
"""
# GIVEN: An image to create a thumb of.
image_path = os.path.join(TEST_PATH, 'church.jpg')
thumb_path = os.path.join(TEST_PATH, 'church_thumb.jpg')
image_path = Path(TEST_PATH, 'church.jpg')
thumb_path = Path(TEST_PATH, 'church_thumb.jpg')
thumb_size = QtCore.QSize(-1, 100)
expected_size = QtCore.QSize(72, 100)
# Remove the thumb so that the test actually tests if the thumb will be created. Maybe it was not deleted in the
# last test.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
# Only continue when the thumb does not exist.
self.assertFalse(os.path.exists(thumb_path), 'Test was not run, because the thumb already exists.')
self.assertFalse(thumb_path.exists(), 'Test was not run, because the thumb already exists.')
# WHEN: Create the thumb.
icon = create_thumb(image_path, thumb_path, size=thumb_size)
# THEN: Check if the thumb was created, retaining its aspect ratio.
self.assertTrue(os.path.exists(thumb_path), 'Test was not ran, because the thumb already exists')
self.assertTrue(thumb_path.exists(), 'Test was not ran, because the thumb already exists')
self.assertIsInstance(icon, QtGui.QIcon, 'The icon should be a QIcon')
self.assertFalse(icon.isNull(), 'The icon should not be null')
self.assertEqual(expected_size, QtGui.QImageReader(thumb_path).size(), 'The thumb should have the given size')
self.assertEqual(expected_size, QtGui.QImageReader(str(thumb_path)).size(), 'The thumb should have the given size')
# Remove the thumb so that the test actually tests if the thumb will be created.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
@ -447,8 +449,8 @@ class TestLib(TestCase):
Test the create_thumb() function with a size of only height specified.
"""
# GIVEN: An image to create a thumb of.
image_path = os.path.join(TEST_PATH, 'church.jpg')
thumb_path = os.path.join(TEST_PATH, 'church_thumb.jpg')
image_path = Path(TEST_PATH, 'church.jpg')
thumb_path = Path(TEST_PATH, 'church_thumb.jpg')
thumb_size = QtCore.QSize(-1, 100)
expected_size_1 = QtCore.QSize(88, 88)
expected_size_2 = QtCore.QSize(100, 100)
@ -456,12 +458,12 @@ class TestLib(TestCase):
# Remove the thumb so that the test actually tests if the thumb will be created. Maybe it was not deleted in the
# last test.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass
# Only continue when the thumb does not exist.
self.assertFalse(os.path.exists(thumb_path), 'Test was not run, because the thumb already exists.')
self.assertFalse(thumb_path.exists(), 'Test was not run, because the thumb already exists.')
# WHEN: Create the thumb.
with patch('openlp.core.lib.QtGui.QImageReader.size') as mocked_size:
@ -469,10 +471,10 @@ class TestLib(TestCase):
icon = create_thumb(image_path, thumb_path, size=None)
# THEN: Check if the thumb was created with aspect ratio of 1.
self.assertTrue(os.path.exists(thumb_path), 'Test was not ran, because the thumb already exists')
self.assertTrue(thumb_path.exists(), 'Test was not ran, because the thumb already exists')
self.assertIsInstance(icon, QtGui.QIcon, 'The icon should be a QIcon')
self.assertFalse(icon.isNull(), 'The icon should not be null')
self.assertEqual(expected_size_1, QtGui.QImageReader(thumb_path).size(), 'The thumb should have the given size')
self.assertEqual(expected_size_1, QtGui.QImageReader(str(thumb_path)).size(), 'The thumb should have the given size')
# WHEN: Create the thumb.
with patch('openlp.core.lib.QtGui.QImageReader.size') as mocked_size:
@ -482,11 +484,11 @@ class TestLib(TestCase):
# THEN: Check if the thumb was created with aspect ratio of 1.
self.assertIsInstance(icon, QtGui.QIcon, 'The icon should be a QIcon')
self.assertFalse(icon.isNull(), 'The icon should not be null')
self.assertEqual(expected_size_2, QtGui.QImageReader(thumb_path).size(), 'The thumb should have the given size')
self.assertEqual(expected_size_2, QtGui.QImageReader(str(thumb_path)).size(), 'The thumb should have the given size')
# Remove the thumb so that the test actually tests if the thumb will be created.
try:
os.remove(thumb_path)
thumb_path.unlink()
except:
pass

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

@ -199,16 +199,16 @@ class TestThemeManager(TestCase):
theme_manager._create_theme_from_xml = MagicMock()
theme_manager.generate_and_save_image = MagicMock()
theme_manager.theme_path = None
folder = Path(mkdtemp())
folder_path = Path(mkdtemp())
theme_file = Path(TEST_RESOURCES_PATH, 'themes', 'Moss_on_tree.otz')
# WHEN: We try to unzip it
theme_manager.unzip_theme(theme_file, folder)
theme_manager.unzip_theme(theme_file, folder_path)
# THEN: Files should be unpacked
self.assertTrue((folder / 'Moss on tree' / 'Moss on tree.xml').exists())
self.assertTrue((folder_path / 'Moss on tree' / 'Moss on tree.xml').exists())
self.assertEqual(mocked_critical_error_message_box.call_count, 0, 'No errors should have happened')
shutil.rmtree(str(folder))
folder_path.rmtree()
def test_unzip_theme_invalid_version(self):
"""

20
tests/functional/openlp_plugins/presentations/test_pdfcontroller.py
View File

@ -67,10 +67,10 @@ class TestPdfController(TestCase, TestMixin):
self.desktop.screenGeometry.return_value = SCREEN['size']
self.screens = ScreenList.create(self.desktop)
Settings().extend_default_settings(__default_settings__)
self.temp_folder = Path(mkdtemp())
self.thumbnail_folder = Path(mkdtemp())
self.temp_folder_path = Path(mkdtemp())
self.thumbnail_folder_path = Path(mkdtemp())
self.mock_plugin = MagicMock()
self.mock_plugin.settings_section = self.temp_folder
self.mock_plugin.settings_section = self.temp_folder_path
def tearDown(self):
"""
@ -78,8 +78,8 @@ class TestPdfController(TestCase, TestMixin):
"""
del self.screens
self.destroy_settings()
shutil.rmtree(str(self.thumbnail_folder))
shutil.rmtree(str(self.temp_folder))
self.thumbnail_folder_path.rmtree()
self.temp_folder_path.rmtree()
def test_constructor(self):
"""
@ -105,8 +105,8 @@ class TestPdfController(TestCase, TestMixin):
controller = PdfController(plugin=self.mock_plugin)
if not controller.check_available():
raise SkipTest('Could not detect mudraw or ghostscript, so skipping PDF test')
controller.temp_folder = self.temp_folder
controller.thumbnail_folder = self.thumbnail_folder
controller.temp_folder = self.temp_folder_path
controller.thumbnail_folder = self.thumbnail_folder_path
document = PdfDocument(controller, test_file)
loaded = document.load_presentation()
@ -125,14 +125,14 @@ class TestPdfController(TestCase, TestMixin):
controller = PdfController(plugin=self.mock_plugin)
if not controller.check_available():
raise SkipTest('Could not detect mudraw or ghostscript, so skipping PDF test')
controller.temp_folder = self.temp_folder
controller.thumbnail_folder = self.thumbnail_folder
controller.temp_folder = self.temp_folder_path
controller.thumbnail_folder = self.thumbnail_folder_path
document = PdfDocument(controller, test_file)
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.')
image = QtGui.QImage(os.path.join(str(self.temp_folder), 'pdf_test1.pdf', 'mainslide001.png'))
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:
self.assertEqual(760, image.height(), 'The height should be 760')

7
tests/interfaces/openlp_core/lib/test_pluginmanager.py
View File

@ -23,7 +23,6 @@
Package to test the openlp.core.lib.pluginmanager package.
"""
import sys
import shutil
import gc
from tempfile import mkdtemp
from unittest import TestCase
@ -50,8 +49,8 @@ class TestPluginManager(TestCase, TestMixin):
"""
self.setup_application()
self.build_settings()
self.temp_dir = Path(mkdtemp('openlp'))
Settings().setValue('advanced/data path', self.temp_dir)
self.temp_dir_path = Path(mkdtemp('openlp'))
Settings().setValue('advanced/data path', self.temp_dir_path)
Registry.create()
Registry().register('service_list', MagicMock())
self.main_window = QtWidgets.QMainWindow()
@ -64,7 +63,7 @@ class TestPluginManager(TestCase, TestMixin):
# On windows we need to manually garbage collect to close sqlalchemy files
# to avoid errors when temporary files are deleted.
gc.collect()
shutil.rmtree(str(self.temp_dir))
self.temp_dir_path.rmtree()
@patch('openlp.plugins.songusage.lib.db.init_schema')
@patch('openlp.plugins.songs.lib.db.init_schema')