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

Refactor asserts in api and common packages

Browse Source 
lp:~trb143/openlp/asserts (revision 2809)
https://ci.openlp.io/job/Branch-01-Pull/2354/                          [SUCCESS]
https://ci.openlp.io/job/Branch-02-Functional-Tests/2255/              [SUCCESS]
https://ci.openlp.io/job/Branch-03-Interface-Tests/2120/               [SUCCESS]
https://ci.openlp.io/job/Branch-04a-Code_Analysis/1446/                [SUCCESS]
https://ci.openlp.io/job/Branch-04b-Test_Coverage/1263/                [SUCCESS]
https...

bzr-revno: 2796
This commit is contained in:
Tim Bentley 2017-12-17 14:02:03 +00:00
commit 2312c7f246
17 changed files with 167 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
tests/functional/openlp_core/api/http/test_error.py
View File

@ -42,8 +42,8 @@ class TestApiError(TestCase):
raise NotFound()
# THEN: we get an error and a status
self.assertEquals('Not Found', context.exception.message, 'A Not Found exception should be thrown')
self.assertEquals(404, context.exception.status, 'A 404 status should be thrown')
assert 'Not Found' == context.exception.message, 'A Not Found exception should be thrown'
assert 404 == context.exception.status, 'A 404 status should be thrown'
def test_server_error(self):
"""
@ -55,5 +55,5 @@ class TestApiError(TestCase):
raise ServerError()
# THEN: we get an error and a status
self.assertEquals('Server Error', context.exception.message, 'A Not Found exception should be thrown')
self.assertEquals(500, context.exception.status, 'A 500 status should be thrown')
assert'Server Error' == context.exception.message, 'A Not Found exception should be thrown'
assert 500 == context.exception.status, 'A 500 status should be thrown'

8
tests/functional/openlp_core/api/http/test_http.py
View File

@ -53,8 +53,8 @@ class TestHttpServer(TestCase):
HttpServer()
# THEN: the api environment should have been created
self.assertEquals(1, mock_qthread.call_count, 'The qthread should have been called once')
self.assertEquals(1, mock_thread.call_count, 'The http thread should have been called once')
assert mock_qthread.call_count == 1, 'The qthread should have been called once'
assert mock_thread.call_count == 1, 'The http thread should have been called once'
@patch('openlp.core.api.http.server.HttpWorker')
@patch('openlp.core.api.http.server.QtCore.QThread')
@ -68,5 +68,5 @@ class TestHttpServer(TestCase):
HttpServer()
# THEN: the api environment should have been created
self.assertEquals(0, mock_qthread.call_count, 'The qthread should not have have been called')
self.assertEquals(0, mock_thread.call_count, 'The http thread should not have been called')
assert mock_qthread.call_count == 0, 'The qthread should not have have been called'
assert mock_thread.call_count == 0, 'The http thread should not have been called'

6
tests/functional/openlp_core/api/http/test_wsgiapp.py
View File

@ -61,7 +61,7 @@ class TestRouting(TestCase):
application.dispatch(rqst)
# THEN: the not found returned
self.assertEqual(context.exception.args[0], 'Not Found', 'URL not found in dispatcher')
assert context.exception.args[0] == 'Not Found', 'URL not found in dispatcher'
# WHEN: when the URL is correct and dispatch called
rqst = MagicMock()
@ -69,8 +69,8 @@ class TestRouting(TestCase):
rqst.method = 'GET'
application.dispatch(rqst)
# THEN: the not found id called
self.assertEqual(1, application.route_map['^\\/test\\/image$']['GET'].call_count,
'main_index function should have been called')
assert 1 == application.route_map['^\\/test\\/image$']['GET'].call_count, \
'main_index function should have been called'
@test_endpoint.route('image')

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

@ -58,4 +58,4 @@ class TestRemoteDeploy(TestCase):
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')
assert (self.app_root_path / 'www').is_dir(), 'We should have a www directory'

23
tests/functional/openlp_core/api/test_tab.py
View File

@ -81,8 +81,8 @@ class TestApiTab(TestCase, TestMixin):
# WHEN: the default ip address is given
ip_address = self.form.get_ip_address(ZERO_URL)
# THEN: the default ip address will be returned
self.assertTrue(re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', ip_address),
'The return value should be a valid ip address')
assert re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', ip_address), \
'The return value should be a valid ip address'
def test_get_ip_address_with_ip(self):
"""
@ -93,7 +93,7 @@ class TestApiTab(TestCase, TestMixin):
# WHEN: the default ip address is given
ip_address = self.form.get_ip_address(given_ip)
# THEN: the default ip address will be returned
self.assertEqual(ip_address, given_ip, 'The return value should be %s' % given_ip)
assert ip_address == given_ip, 'The return value should be %s' % given_ip
def test_set_urls(self):
"""
@ -104,12 +104,11 @@ class TestApiTab(TestCase, TestMixin):
# WHEN: the urls are generated
self.form.set_urls()
# THEN: the following links are returned
self.assertEqual(self.form.remote_url.text(),
"<a href=\"http://192.168.1.1:4316/\">http://192.168.1.1:4316/</a>",
'The return value should be a fully formed link')
self.assertEqual(self.form.stage_url.text(),
"<a href=\"http://192.168.1.1:4316/stage\">http://192.168.1.1:4316/stage</a>",
'The return value should be a fully formed stage link')
self.assertEqual(self.form.live_url.text(),
"<a href=\"http://192.168.1.1:4316/main\">http://192.168.1.1:4316/main</a>",
'The return value should be a fully formed main link')
assert self.form.remote_url.text() == "<a href=\"http://192.168.1.1:4316/\">http://192.168.1.1:4316/</a>", \
'The return value should be a fully formed link'
assert self.form.stage_url.text() == \
"<a href=\"http://192.168.1.1:4316/stage\">http://192.168.1.1:4316/stage</a>", \
'The return value should be a fully formed stage link'
assert self.form.live_url.text() == \
"<a href=\"http://192.168.1.1:4316/main\">http://192.168.1.1:4316/main</a>", \
'The return value should be a fully formed main link'

31
tests/functional/openlp_core/api/test_websockets.py
View File

@ -74,8 +74,8 @@ class TestWSServer(TestCase, TestMixin):
WebSocketServer()
# THEN: the api environment should have been created
self.assertEquals(1, mock_qthread.call_count, 'The qthread should have been called once')
self.assertEquals(1, mock_worker.call_count, 'The http thread should have been called once')
assert mock_qthread.call_count == 1, 'The qthread should have been called once'
assert mock_worker.call_count == 1, 'The http thread should have been called once'
@patch('openlp.core.api.websockets.WebSocketWorker')
@patch('openlp.core.api.websockets.QtCore.QThread')
@ -89,8 +89,8 @@ class TestWSServer(TestCase, TestMixin):
WebSocketServer()
# THEN: the api environment should have been created
self.assertEquals(0, mock_qthread.call_count, 'The qthread should not have been called')
self.assertEquals(0, mock_worker.call_count, 'The http thread should not have been called')
assert mock_qthread.call_count == 0, 'The qthread should not have been called'
assert mock_worker.call_count == 0, 'The http thread should not have been called'
def test_main_poll(self):
"""
@ -102,8 +102,7 @@ class TestWSServer(TestCase, TestMixin):
Registry().register('live_controller', mocked_live_controller)
# THEN: the live json should be generated
main_json = self.poll.main_poll()
self.assertEquals(b'{"results": {"slide_count": 5}}', main_json,
'The return value should match the defined json')
assert b'{"results": {"slide_count": 5}}' == main_json, 'The return value should match the defined json'
def test_poll(self):
"""
@ -130,13 +129,13 @@ class TestWSServer(TestCase, TestMixin):
mocked_is_chords_active.return_value = True
poll_json = self.poll.poll()
# THEN: the live json should be generated and match expected results
self.assertTrue(poll_json['results']['blank'], 'The blank return value should be True')
self.assertFalse(poll_json['results']['theme'], 'The theme return value should be False')
self.assertFalse(poll_json['results']['display'], 'The display return value should be False')
self.assertFalse(poll_json['results']['isSecure'], 'The isSecure return value should be False')
self.assertFalse(poll_json['results']['isAuthorised'], 'The isAuthorised return value should be False')
self.assertTrue(poll_json['results']['twelve'], 'The twelve return value should be False')
self.assertEquals(poll_json['results']['version'], 3, 'The version return value should be 3')
self.assertEquals(poll_json['results']['slide'], 5, 'The slide return value should be 5')
self.assertEquals(poll_json['results']['service'], 21, 'The version return value should be 21')
self.assertEquals(poll_json['results']['item'], '23-34-45', 'The item return value should match 23-34-45')
assert poll_json['results']['blank'] is True, 'The blank return value should be True'
assert poll_json['results']['theme'] is False, 'The theme return value should be False'
assert poll_json['results']['display'] is False, 'The display return value should be False'
assert poll_json['results']['isSecure'] is False, 'The isSecure return value should be False'
assert poll_json['results']['isAuthorised'] is False, 'The isAuthorised return value should be False'
assert poll_json['results']['twelve'] is True, 'The twelve return value should be True'
assert poll_json['results']['version'] == 3, 'The version return value should be 3'
assert poll_json['results']['slide'] == 5, 'The slide return value should be 5'
assert poll_json['results']['service'] == 21, 'The version return value should be 21'
assert poll_json['results']['item'] == '23-34-45', 'The item return value should match 23-34-45'

34
tests/functional/openlp_core/common/test_actions.py
View File

@ -59,8 +59,8 @@ class TestCategoryActionList(TestCase):
self.list.append(self.action1)
# THEN: The actions should (not) be in the list.
self.assertTrue(self.action1 in self.list)
self.assertFalse(self.action2 in self.list)
assert self.action1 in self.list
assert self.action2 not in self.list
def test_len(self):
"""
@ -69,14 +69,14 @@ class TestCategoryActionList(TestCase):
# GIVEN: The list.
# WHEN: Do nothing.
# THEN: Check the length.
self.assertEqual(len(self.list), 0, "The length should be 0.")
assert len(self.list) == 0, "The length should be 0."
# GIVEN: The list.
# WHEN: Append an action.
self.list.append(self.action1)
# THEN: Check the length.
self.assertEqual(len(self.list), 1, "The length should be 1.")
assert len(self.list) == 1, "The length should be 1."
def test_append(self):
"""
@ -88,10 +88,10 @@ class TestCategoryActionList(TestCase):
self.list.append(self.action2)
# THEN: Check if the actions are in the list and check if they have the correct weights.
self.assertTrue(self.action1 in self.list)
self.assertTrue(self.action2 in self.list)
self.assertEqual(self.list.actions[0], (0, self.action1))
self.assertEqual(self.list.actions[1], (1, self.action2))
assert self.action1 in self.list
assert self.action2 in self.list
assert self.list.actions[0] == (0, self.action1)
assert self.list.actions[1] == (1, self.action2)
def test_add(self):
"""
@ -106,11 +106,11 @@ class TestCategoryActionList(TestCase):
self.list.add(self.action2, action2_weight)
# THEN: Check if they were added and have the specified weights.
self.assertTrue(self.action1 in self.list)
self.assertTrue(self.action2 in self.list)
assert self.action1 in self.list
assert self.action2 in self.list
# Now check if action1 is second and action2 is first (due to their weights).
self.assertEqual(self.list.actions[0], (41, self.action2))
self.assertEqual(self.list.actions[1], (42, self.action1))
assert self.list.actions[0] == (41, self.action2)
assert self.list.actions[1] == (42, self.action1)
def test_iterator(self):
"""
@ -121,11 +121,11 @@ class TestCategoryActionList(TestCase):
self.list.add(self.action2)
# WHEN: Iterating over the list
list = [a for a in self.list]
local_list = [a for a in self.list]
# THEN: Make sure they are returned in correct order
self.assertEquals(len(self.list), 2)
self.assertIs(list[0], self.action1)
self.assertIs(list[1], self.action2)
assert len(self.list) == 2
assert local_list[0] is self.action1
assert local_list[1] is self.action2
def test_remove(self):
"""
@ -138,7 +138,7 @@ class TestCategoryActionList(TestCase):
self.list.remove(self.action1)
# THEN: Now the element should not be in the list anymore.
self.assertFalse(self.action1 in self.list)
assert self.action1 not in self.list
# THEN: Check if an exception is raised when trying to remove a not present action.
self.assertRaises(ValueError, self.list.remove, self.action2)

35
tests/functional/openlp_core/common/test_common.py
View File

@ -48,7 +48,7 @@ class TestCommonFunctions(TestCase):
extension_loader('glob', ['file2.py', 'file3.py'])
# THEN: `extension_loader` should not try to import any files
self.assertFalse(mocked_import_module.called)
assert mocked_import_module.called is False
def test_extension_loader_files_found(self):
"""
@ -69,7 +69,8 @@ class TestCommonFunctions(TestCase):
# THEN: `extension_loader` should only try to import the files that are matched by the blob, excluding the
# files listed in the `excluded_files` argument
mocked_import_module.assert_has_calls([call('openlp.import_dir.file1'), call('openlp.import_dir.file4')])
mocked_import_module.assert_has_calls([call('openlp.import_dir.file1'),
call('openlp.import_dir.file4')])
def test_extension_loader_import_error(self):
"""
@ -87,7 +88,7 @@ class TestCommonFunctions(TestCase):
extension_loader('glob')
# THEN: The `ImportError` should be caught and logged
self.assertTrue(mocked_logger.warning.called)
assert mocked_logger.warning.called
def test_extension_loader_os_error(self):
"""
@ -105,7 +106,7 @@ class TestCommonFunctions(TestCase):
extension_loader('glob')
# THEN: The `OSError` should be caught and logged
self.assertTrue(mocked_logger.warning.called)
assert mocked_logger.warning.called
def test_de_hump_conversion(self):
"""
@ -118,7 +119,7 @@ class TestCommonFunctions(TestCase):
new_string = de_hump(string)
# THEN: the new string should be converted to python format
self.assertEqual(new_string, "my_class", 'The class name should have been converted')
assert new_string == "my_class", 'The class name should have been converted'
def test_de_hump_static(self):
"""
@ -131,7 +132,7 @@ class TestCommonFunctions(TestCase):
new_string = de_hump(string)
# THEN: the new string should be converted to python format
self.assertEqual(new_string, "my_class", 'The class name should have been preserved')
assert new_string == "my_class", 'The class name should have been preserved'
def test_path_to_module(self):
"""
@ -144,7 +145,7 @@ class TestCommonFunctions(TestCase):
result = path_to_module(path)
# THEN: path_to_module should return the module name
self.assertEqual(result, 'openlp.core.ui.media.webkitplayer')
assert result == 'openlp.core.ui.media.webkitplayer'
def test_trace_error_handler(self):
"""
@ -174,9 +175,9 @@ class TestCommonFunctions(TestCase):
mocked_sys.platform = 'win32'
# THEN: The three platform functions should perform properly
self.assertTrue(is_win(), 'is_win() should return True')
self.assertFalse(is_macosx(), 'is_macosx() should return False')
self.assertFalse(is_linux(), 'is_linux() should return False')
assert is_win() is True, 'is_win() should return True'
assert is_macosx() is False, 'is_macosx() should return False'
assert is_linux() is False, 'is_linux() should return False'
def test_is_macosx(self):
"""
@ -190,9 +191,9 @@ class TestCommonFunctions(TestCase):
mocked_sys.platform = 'darwin'
# THEN: The three platform functions should perform properly
self.assertTrue(is_macosx(), 'is_macosx() should return True')
self.assertFalse(is_win(), 'is_win() should return False')
self.assertFalse(is_linux(), 'is_linux() should return False')
assert is_macosx() is True, 'is_macosx() should return True'
assert is_win() is False, 'is_win() should return False'
assert is_linux() is False, 'is_linux() should return False'
def test_is_linux(self):
"""
@ -206,9 +207,9 @@ class TestCommonFunctions(TestCase):
mocked_sys.platform = 'linux3'
# THEN: The three platform functions should perform properly
self.assertTrue(is_linux(), 'is_linux() should return True')
self.assertFalse(is_win(), 'is_win() should return False')
self.assertFalse(is_macosx(), 'is_macosx() should return False')
assert is_linux() is True, 'is_linux() should return True'
assert is_win() is False, 'is_win() should return False'
assert is_macosx() is False, 'is_macosx() should return False'
def test_clean_button_text(self):
"""
@ -222,4 +223,4 @@ class TestCommonFunctions(TestCase):
actual_text = clean_button_text(input_text)
# THEN: The text should have been cleaned
self.assertEqual(expected_text, actual_text, 'The text should be clean')
assert expected_text == actual_text, 'The text should be clean'

12
tests/functional/openlp_core/common/test_httputils.py
View File

@ -59,7 +59,7 @@ class TestHttpUtils(TestCase, TestMixin):
# THEN: The user agent is a Linux (or ChromeOS) user agent
result = 'Linux' in user_agent or 'CrOS' in user_agent
self.assertTrue(result, 'The user agent should be a valid Linux user agent')
assert result is True, 'The user agent should be a valid Linux user agent'
def test_get_user_agent_windows(self):
"""
@ -74,7 +74,7 @@ class TestHttpUtils(TestCase, TestMixin):
user_agent = get_user_agent()
# THEN: The user agent is a Linux (or ChromeOS) user agent
self.assertIn('Windows', user_agent, 'The user agent should be a valid Windows user agent')
assert 'Windows' in user_agent, 'The user agent should be a valid Windows user agent'
def test_get_user_agent_macos(self):
"""
@ -89,7 +89,7 @@ class TestHttpUtils(TestCase, TestMixin):
user_agent = get_user_agent()
# THEN: The user agent is a Linux (or ChromeOS) user agent
self.assertIn('Mac OS X', user_agent, 'The user agent should be a valid OS X user agent')
assert 'Mac OS X' in user_agent, 'The user agent should be a valid OS X user agent'
def test_get_user_agent_default(self):
"""
@ -104,7 +104,7 @@ class TestHttpUtils(TestCase, TestMixin):
user_agent = get_user_agent()
# THEN: The user agent is a Linux (or ChromeOS) user agent
self.assertIn('NetBSD', user_agent, 'The user agent should be the default user agent')
assert 'NetBSD'in user_agent, 'The user agent should be the default user agent'
def test_get_web_page_no_url(self):
"""
@ -117,7 +117,7 @@ class TestHttpUtils(TestCase, TestMixin):
result = get_web_page(test_url)
# THEN: None should be returned
self.assertIsNone(result, 'The return value of get_web_page should be None')
assert result is None, 'The return value of get_web_page should be None'
@patch('openlp.core.common.httputils.requests')
@patch('openlp.core.common.httputils.get_user_agent')
@ -240,4 +240,4 @@ class TestHttpUtils(TestCase, TestMixin):
# THEN: socket.timeout should have been caught
# NOTE: Test is if $tmpdir/tempfile is still there, then test fails since ftw deletes bad downloaded files
assert not os.path.exists(self.tempfile), 'tempfile should have been deleted'
assert os.path.exists(self.tempfile) is False, 'tempfile should have been deleted'

51
tests/functional/openlp_core/common/test_init.py
View File

@ -63,8 +63,8 @@ class TestInit(TestCase, TestMixin):
add_actions(mocked_target, empty_list)
# THEN: The add method on the mocked target is never called
self.assertEqual(0, mocked_target.addSeparator.call_count, 'addSeparator method should not have been called')
self.assertEqual(0, mocked_target.addAction.call_count, 'addAction method should not have been called')
assert mocked_target.addSeparator.call_count == 0, 'addSeparator method should not have been called'
assert mocked_target.addAction.call_count == 0, 'addAction method should not have been called'
def test_add_actions_none_action(self):
"""
@ -79,7 +79,7 @@ class TestInit(TestCase, TestMixin):
# THEN: The addSeparator method is called, but the addAction method is never called
mocked_target.addSeparator.assert_called_with()
self.assertEqual(0, mocked_target.addAction.call_count, 'addAction method should not have been called')
assert mocked_target.addAction.call_count == 0, 'addAction method should not have been called'
def test_add_actions_add_action(self):
"""
@ -93,7 +93,7 @@ class TestInit(TestCase, TestMixin):
add_actions(mocked_target, action_list)
# THEN: The addSeparator method is not called, and the addAction method is called
self.assertEqual(0, mocked_target.addSeparator.call_count, 'addSeparator method should not have been called')
assert mocked_target.addSeparator.call_count == 0, 'addSeparator method should not have been called'
mocked_target.addAction.assert_called_with('action')
def test_add_actions_action_and_none(self):
@ -150,9 +150,8 @@ class TestInit(TestCase, TestMixin):
result = get_uno_command()
# THEN: The command 'libreoffice' should be called with the appropriate parameters
self.assertEquals(result,
'libreoffice --nologo --norestore --minimized --nodefault --nofirststartwizard'
' "--accept=pipe,name=openlp_pipe;urp;"')
assert result == 'libreoffice --nologo --norestore --minimized --nodefault --nofirststartwizard' \
' "--accept=pipe,name=openlp_pipe;urp;"'
def test_get_uno_command_only_soffice_command_exists(self):
"""
@ -169,8 +168,8 @@ class TestInit(TestCase, TestMixin):
result = get_uno_command()
# THEN: The command 'soffice' should be called with the appropriate parameters
self.assertEquals(result, 'soffice --nologo --norestore --minimized --nodefault --nofirststartwizard'
' "--accept=pipe,name=openlp_pipe;urp;"')
assert result == 'soffice --nologo --norestore --minimized --nodefault --nofirststartwizard' \
' "--accept=pipe,name=openlp_pipe;urp;"'
def test_get_uno_command_when_no_command_exists(self):
"""
@ -198,8 +197,8 @@ class TestInit(TestCase, TestMixin):
result = get_uno_command('socket')
# THEN: The connection parameters should be set for socket
self.assertEqual(result, 'libreoffice --nologo --norestore --minimized --nodefault --nofirststartwizard'
' "--accept=socket,host=localhost,port=2002;urp;"')
assert result == 'libreoffice --nologo --norestore --minimized --nodefault --nofirststartwizard' \
' "--accept=socket,host=localhost,port=2002;urp;"'
def test_get_filesystem_encoding_sys_function_not_called(self):
"""
@ -215,8 +214,8 @@ class TestInit(TestCase, TestMixin):
# THEN: getdefaultencoding should have been called
mocked_getfilesystemencoding.assert_called_with()
self.assertEqual(0, mocked_getdefaultencoding.called, 'getdefaultencoding should not have been called')
self.assertEqual('cp1252', result, 'The result should be "cp1252"')
assert mocked_getdefaultencoding.called == 0, 'getdefaultencoding should not have been called'
assert 'cp1252' == result, 'The result should be "cp1252"'
def test_get_filesystem_encoding_sys_function_is_called(self):
"""
@ -234,7 +233,7 @@ class TestInit(TestCase, TestMixin):
# THEN: getdefaultencoding should have been called
mocked_getfilesystemencoding.assert_called_with()
mocked_getdefaultencoding.assert_called_with()
self.assertEqual('utf-8', result, 'The result should be "utf-8"')
assert 'utf-8' == result, 'The result should be "utf-8"'
def test_clean_filename(self):
"""
@ -248,7 +247,7 @@ class TestInit(TestCase, TestMixin):
result = clean_filename(invalid_name)
# THEN: The file name should be cleaned.
self.assertEqual(wanted_name, result, 'The file name should not contain any special characters.')
assert wanted_name == result, 'The file name should not contain any special characters.'
def test_delete_file_no_path(self):
"""
@ -259,7 +258,7 @@ class TestInit(TestCase, TestMixin):
result = delete_file(None)
# THEN: delete_file should return False
self.assertFalse(result, "delete_file should return False when called with None")
assert result is False, "delete_file should return False when called with None"
def test_delete_file_path_success(self):
"""
@ -272,7 +271,7 @@ class TestInit(TestCase, TestMixin):
result = delete_file(Path('path', 'file.ext'))
# THEN: delete_file should return True
self.assertTrue(result, 'delete_file should return True when it successfully deletes a file')
assert result is True, 'delete_file should return True when it successfully deletes a file'
def test_delete_file_path_no_file_exists(self):
"""
@ -286,8 +285,8 @@ class TestInit(TestCase, TestMixin):
result = delete_file(Path('path', 'file.ext'))
# THEN: The function should not attempt to delete the file and it should return True
self.assertFalse(mocked_unlink.called)
self.assertTrue(result, 'delete_file should return True when the file doesnt exist')
assert mocked_unlink.called is False
assert result is True, 'delete_file should return True when the file doesnt exist'
def test_delete_file_path_exception(self):
"""
@ -303,8 +302,8 @@ class TestInit(TestCase, TestMixin):
result = delete_file(Path('path', 'file.ext'))
# THEN: The exception should be logged and `delete_file` should return False
self.assertTrue(mocked_log.exception.called)
self.assertFalse(result, 'delete_file should return False when an OSError is raised')
assert mocked_log.exception.called
assert result is False, 'delete_file should return False when an OSError is raised'
def test_get_file_encoding_done(self):
"""
@ -323,9 +322,9 @@ class TestInit(TestCase, TestMixin):
# THEN: The feed method of UniversalDetector should only br called once before returning a result
mocked_open.assert_called_once_with('rb')
self.assertEqual(mocked_universal_detector_inst.feed.mock_calls, [call(b"data" * 256)])
assert mocked_universal_detector_inst.feed.mock_calls == [call(b"data" * 256)]
mocked_universal_detector_inst.close.assert_called_once_with()
self.assertEqual(result, encoding_result)
assert result == encoding_result
def test_get_file_encoding_eof(self):
"""
@ -345,9 +344,9 @@ class TestInit(TestCase, TestMixin):
# THEN: The feed method of UniversalDetector should have been called twice before returning a result
mocked_open.assert_called_once_with('rb')
self.assertEqual(mocked_universal_detector_inst.feed.mock_calls, [call(b"data" * 256), call(b"data" * 4)])
assert mocked_universal_detector_inst.feed.mock_calls == [call(b"data" * 256), call(b"data" * 4)]
mocked_universal_detector_inst.close.assert_called_once_with()
self.assertEqual(result, encoding_result)
assert result == encoding_result
def test_get_file_encoding_oserror(self):
"""
@ -364,4 +363,4 @@ class TestInit(TestCase, TestMixin):
# THEN: log.exception should be called and get_file_encoding should return None
mocked_log.exception.assert_called_once_with('Error detecting file encoding')
self.assertIsNone(result)
assert result is None

12
tests/functional/openlp_core/common/test_json.py
View File

@ -45,7 +45,7 @@ class TestOpenLPJsonDecoder(TestCase):
result = instance.object_hook({'__Path__': ['test', 'path']})
# THEN: A Path object should be returned
self.assertEqual(result, Path('test', 'path'))
assert result == Path('test', 'path')
def test_object_hook_non_path_object(self):
"""
@ -59,8 +59,8 @@ class TestOpenLPJsonDecoder(TestCase):
result = instance.object_hook({'key': 'value'})
# THEN: The object should be returned unchanged and a Path object should not have been initiated
self.assertEqual(result, {'key': 'value'})
self.assertFalse(mocked_path.called)
assert result == {'key': 'value'}
assert mocked_path.called is False
def test_json_decode(self):
"""
@ -73,7 +73,7 @@ class TestOpenLPJsonDecoder(TestCase):
obj = json.loads(json_string, cls=OpenLPJsonDecoder)
# THEN: The object returned should be a python version of the JSON string
self.assertEqual(obj, [Path('test', 'path1'), Path('test', 'path2')])
assert obj == [Path('test', 'path1'), Path('test', 'path2')]
class TestOpenLPJsonEncoder(TestCase):
@ -91,7 +91,7 @@ class TestOpenLPJsonEncoder(TestCase):
result = instance.default(Path('test', 'path'))
# THEN: A dictionary object that can be JSON encoded should be returned
self.assertEqual(result, {'__Path__': ('test', 'path')})
assert result == {'__Path__': ('test', 'path')}
def test_default_non_path_object(self):
"""
@ -119,4 +119,4 @@ class TestOpenLPJsonEncoder(TestCase):
json_string = json.dumps(obj, cls=OpenLPJsonEncoder)
# THEN: The JSON string return should be a representation of the object encoded
self.assertEqual(json_string, '[{"__Path__": ["test", "path1"]}, {"__Path__": ["test", "path2"]}]')
assert json_string == '[{"__Path__": ["test", "path1"]}, {"__Path__": ["test", "path2"]}]'

8
tests/functional/openlp_core/common/test_mixins.py
View File

@ -46,7 +46,7 @@ class TestRegistryProperties(TestCase, RegistryProperties):
# GIVEN an Empty Registry
# WHEN there is no Application
# THEN the application should be none
self.assertEqual(self.application, None, 'The application value should be None')
assert self.application is None, 'The application value should be None'
def test_application(self):
"""
@ -59,7 +59,7 @@ class TestRegistryProperties(TestCase, RegistryProperties):
Registry().register('application', application)
# THEN the application should be none
self.assertEqual(self.application, application, 'The application value should match')
assert self.application == application, 'The application value should match'
@patch('openlp.core.common.mixins.is_win')
def test_application_on_windows(self, mocked_is_win):
@ -74,7 +74,7 @@ class TestRegistryProperties(TestCase, RegistryProperties):
Registry().register('application', application)
# THEN the application should be none
self.assertEqual(self.application, application, 'The application value should match')
assert self.application == application, 'The application value should match'
@patch('openlp.core.common.mixins.is_win')
def test_get_application_on_windows(self, mocked_is_win):
@ -93,6 +93,6 @@ class TestRegistryProperties(TestCase, RegistryProperties):
actual_application = reg_props.application
# THEN the application should be the mock object, and the correct function should have been called
self.assertEqual(mock_application, actual_application, 'The application value should match')
assert mock_application == actual_application, 'The application value should match'
mocked_is_win.assert_called_with()
mocked_get.assert_called_with('application')

35
tests/functional/openlp_core/common/test_path.py
View File

@ -47,8 +47,8 @@ class TestShutil(TestCase):
result_args, result_kwargs = replace_params(test_args, test_kwargs, test_params)
# THEN: The positional and keyword args should not have changed
self.assertEqual(test_args, result_args)
self.assertEqual(test_kwargs, result_kwargs)
assert test_args == result_args
assert test_kwargs == result_kwargs
def test_replace_params_params(self):
"""
@ -63,8 +63,8 @@ class TestShutil(TestCase):
result_args, result_kwargs = replace_params(test_args, test_kwargs, test_params)
# THEN: The positional and keyword args should have have changed
self.assertEqual(result_args, (1, '2'))
self.assertEqual(result_kwargs, {'arg3': '3', 'arg4': 4})
assert result_args == (1, '2')
assert result_kwargs == {'arg3': '3', 'arg4': 4}
def test_copy(self):
"""
@ -82,7 +82,7 @@ class TestShutil(TestCase):
# :func:`shutil.copy` as a Path object.
mocked_shutil_copy.assert_called_once_with(os.path.join('source', 'test', 'path'),
os.path.join('destination', 'test', 'path'))
self.assertEqual(result, Path('destination', 'test', 'path'))
assert result == Path('destination', 'test', 'path')
def test_copy_follow_optional_params(self):
"""
@ -114,7 +114,7 @@ class TestShutil(TestCase):
# :func:`shutil.copyfile` as a Path object.
mocked_shutil_copyfile.assert_called_once_with(os.path.join('source', 'test', 'path'),
os.path.join('destination', 'test', 'path'))
self.assertEqual(result, Path('destination', 'test', 'path'))
assert result == Path('destination', 'test', 'path')
def test_copyfile_optional_params(self):
"""
@ -147,7 +147,7 @@ class TestShutil(TestCase):
# :func:`shutil.copytree` as a Path object.
mocked_shutil_copytree.assert_called_once_with(os.path.join('source', 'test', 'path'),
os.path.join('destination', 'test', 'path'))
self.assertEqual(result, Path('destination', 'test', 'path'))
assert result == Path('destination', 'test', 'path')
def test_copytree_optional_params(self):
"""
@ -177,12 +177,11 @@ class TestShutil(TestCase):
path = Path('test', 'path')
# WHEN: Calling :func:`openlp.core.common.path.rmtree` with the path parameter as Path object type
result = path.rmtree()
path.rmtree()
# THEN: :func:`shutil.rmtree` should have been called with the str equivalents of the Path object.
mocked_shutil_rmtree.assert_called_once_with(
os.path.join('test', 'path'), False, None)
self.assertIsNone(result)
def test_rmtree_optional_params(self):
"""
@ -214,7 +213,7 @@ class TestShutil(TestCase):
# THEN: :func:`shutil.which` should have been called with the command, and :func:`which` should return None.
mocked_shutil_which.assert_called_once_with('no_command')
self.assertIsNone(result)
assert result is None
def test_which_command(self):
"""
@ -230,7 +229,7 @@ class TestShutil(TestCase):
# THEN: :func:`shutil.which` should have been called with the command, and :func:`which` should return a
# Path object equivalent of the command path.
mocked_shutil_which.assert_called_once_with('command')
self.assertEqual(result, Path('path', 'to', 'command'))
assert result == Path('path', 'to', 'command')
class TestPath(TestCase):
@ -257,7 +256,7 @@ class TestPath(TestCase):
result = path_to_str(None)
# THEN: `path_to_str` should return an empty string
self.assertEqual(result, '')
assert result == ''
def test_path_to_str_path_object(self):
"""
@ -268,7 +267,7 @@ class TestPath(TestCase):
result = path_to_str(Path('test/path'))
# THEN: `path_to_str` should return a string representation of the Path object
self.assertEqual(result, os.path.join('test', 'path'))
assert result == os.path.join('test', 'path')
def test_str_to_path_type_error(self):
"""
@ -289,7 +288,7 @@ class TestPath(TestCase):
result = str_to_path('')
# THEN: `path_to_str` should return None
self.assertEqual(result, None)
assert result is None
def test_path_encode_json(self):
"""
@ -301,7 +300,7 @@ class TestPath(TestCase):
path = Path.encode_json({'__Path__': ['path', 'to', 'fi.le']}, extra=1, args=2)
# THEN: A Path object should have been returned
self.assertEqual(path, Path('path', 'to', 'fi.le'))
assert path == Path('path', 'to', 'fi.le')
def test_path_encode_json_base_path(self):
"""
@ -313,7 +312,7 @@ class TestPath(TestCase):
path = Path.encode_json({'__Path__': ['path', 'to', 'fi.le']}, base_path=Path('/base'))
# THEN: A Path object should have been returned with an absolute path
self.assertEqual(path, Path('/', 'base', 'path', 'to', 'fi.le'))
assert path == Path('/', 'base', 'path', 'to', 'fi.le')
def test_path_json_object(self):
"""
@ -326,7 +325,7 @@ class TestPath(TestCase):
obj = path.json_object(extra=1, args=2)
# THEN: A JSON decodable object should have been returned.
self.assertEqual(obj, {'__Path__': ('/', 'base', 'path', 'to', 'fi.le')})
assert obj == {'__Path__': ('/', 'base', 'path', 'to', 'fi.le')}
def test_path_json_object_base_path(self):
"""
@ -340,7 +339,7 @@ class TestPath(TestCase):
obj = path.json_object(base_path=Path('/', 'base'))
# THEN: A JSON decodable object should have been returned.
self.assertEqual(obj, {'__Path__': ('path', 'to', 'fi.le')})
assert obj == {'__Path__': ('path', 'to', 'fi.le')}
def test_create_paths_dir_exists(self):
"""

28
tests/functional/openlp_core/common/test_projector_utilities.py
View File

@ -45,7 +45,7 @@ ip6_link_local = 'fe80::223:14ff:fe99:d315'
ip6_bad = 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
class testProjectorUtilities(TestCase):
class TestProjectorUtilities(TestCase):
"""
Validate functions in the projector utilities module
"""
@ -57,7 +57,7 @@ class testProjectorUtilities(TestCase):
valid = verify_ip_address(addr=ip4_loopback)
# THEN: Verify we received True
self.assertTrue(valid, 'IPv4 loopback address should have been valid')
assert valid, 'IPv4 loopback address should have been valid'
def test_ip4_local_valid(self):
"""
@ -67,7 +67,7 @@ class testProjectorUtilities(TestCase):
valid = verify_ip_address(addr=ip4_local)
# THEN: Verify we received True
self.assertTrue(valid, 'IPv4 local address should have been valid')
assert valid is True, 'IPv4 local address should have been valid'
def test_ip4_broadcast_valid(self):
"""
@ -77,7 +77,7 @@ class testProjectorUtilities(TestCase):
valid = verify_ip_address(addr=ip4_broadcast)
# THEN: Verify we received True
self.assertTrue(valid, 'IPv4 broadcast address should have been valid')
assert valid is True, 'IPv4 broadcast address should have been valid'
def test_ip4_address_invalid(self):
"""
@ -87,7 +87,7 @@ class testProjectorUtilities(TestCase):
valid = verify_ip_address(addr=ip4_bad)
# THEN: Verify we received True
self.assertFalse(valid, 'Bad IPv4 address should not have been valid')
assert valid is False, 'Bad IPv4 address should not have been valid'
def test_ip6_loopback_valid(self):
"""
@ -97,7 +97,7 @@ class testProjectorUtilities(TestCase):
valid = verify_ip_address(addr=ip6_loopback)
# THEN: Validate return
self.assertTrue(valid, 'IPv6 loopback address should have been valid')
assert valid is True, 'IPv6 loopback address should have been valid'
def test_ip6_local_valid(self):
"""
@ -107,7 +107,7 @@ class testProjectorUtilities(TestCase):
valid = verify_ip_address(addr=ip6_link_local)
# THEN: Validate return
self.assertTrue(valid, 'IPv6 link-local address should have been valid')
assert valid is True, 'IPv6 link-local address should have been valid'
def test_ip6_address_invalid(self):
"""
@ -117,7 +117,7 @@ class testProjectorUtilities(TestCase):
valid = verify_ip_address(addr=ip6_bad)
# THEN: Validate bad return
self.assertFalse(valid, 'IPv6 bad address should have been invalid')
assert valid is False, 'IPv6 bad address should have been invalid'
def test_md5_hash(self):
"""
@ -127,7 +127,7 @@ class testProjectorUtilities(TestCase):
hash_ = md5_hash(salt=salt.encode('utf-8'), data=pin.encode('utf-8'))
# THEN: Validate return has is same
self.assertEquals(hash_, test_hash, 'MD5 should have returned a good hash')
assert hash_ == test_hash, 'MD5 should have returned a good hash'
def test_md5_hash_bad(self):
"""
@ -137,7 +137,7 @@ class testProjectorUtilities(TestCase):
hash_ = md5_hash(salt=pin.encode('utf-8'), data=salt.encode('utf-8'))
# THEN: return data is different
self.assertNotEquals(hash_, test_hash, 'MD5 should have returned a bad hash')
assert hash_ is not test_hash, 'MD5 should have returned a bad hash'
def test_qmd5_hash(self):
"""
@ -147,7 +147,7 @@ class testProjectorUtilities(TestCase):
hash_ = qmd5_hash(salt=salt.encode('utf-8'), data=pin.encode('utf-8'))
# THEN: Validate return has is same
self.assertEquals(hash_, test_hash, 'Qt-MD5 should have returned a good hash')
assert hash_ == test_hash, 'Qt-MD5 should have returned a good hash'
def test_qmd5_hash_bad(self):
"""
@ -157,7 +157,7 @@ class testProjectorUtilities(TestCase):
hash_ = qmd5_hash(salt=pin.encode('utf-8'), data=salt.encode('utf-8'))
# THEN: return data is different
self.assertNotEquals(hash_, test_hash, 'Qt-MD5 should have returned a bad hash')
assert hash_ is not test_hash, 'Qt-MD5 should have returned a bad hash'
def test_md5_non_ascii_string(self):
"""
@ -167,7 +167,7 @@ class testProjectorUtilities(TestCase):
hash_ = md5_hash(salt=test_non_ascii_string.encode('utf-8'), data=None)
# THEN: Valid MD5 hash should be returned
self.assertEqual(hash_, test_non_ascii_hash, 'MD5 should have returned a valid hash')
assert hash_ == test_non_ascii_hash, 'MD5 should have returned a valid hash'
def test_qmd5_non_ascii_string(self):
"""
@ -177,4 +177,4 @@ class testProjectorUtilities(TestCase):
hash_ = md5_hash(data=test_non_ascii_string.encode('utf-8'))
# THEN: Valid MD5 hash should be returned
self.assertEqual(hash_, test_non_ascii_hash, 'Qt-MD5 should have returned a valid hash')
assert hash_ == test_non_ascii_hash, 'Qt-MD5 should have returned a valid hash'

32
tests/functional/openlp_core/common/test_registry.py
View File

@ -51,19 +51,19 @@ class TestRegistry(TestCase):
# THEN and I will get an exception
with self.assertRaises(KeyError) as context:
Registry().register('test1', mock_1)
self.assertEqual(context.exception.args[0], 'Duplicate service exception test1',
'KeyError exception should have been thrown for duplicate service')
assert context.exception.args[0] == 'Duplicate service exception test1', \
'KeyError exception should have been thrown for duplicate service'
# WHEN I try to get back a non existent component
# THEN I will get an exception
temp = Registry().get('test2')
self.assertEqual(temp, None, 'None should have been returned for missing service')
assert temp is None, 'None should have been returned for missing service'
# WHEN I try to replace a component I should be allowed
Registry().remove('test1')
# THEN I will get an exception
temp = Registry().get('test1')
self.assertEqual(temp, None, 'None should have been returned for deleted service')
assert temp is None, 'None should have been returned for deleted service'
def test_registry_function(self):
"""
@ -77,21 +77,21 @@ class TestRegistry(TestCase):
return_value = Registry().execute('test1')
# THEN: I expect then function to have been called and a return given
self.assertEqual(return_value[0], 'function_1', 'A return value is provided and matches')
assert return_value[0] == 'function_1', 'A return value is provided and matches'
# WHEN: I execute the a function with the same reference and execute the function
Registry().register_function('test1', self.dummy_function_1)
return_value = Registry().execute('test1')
# THEN: I expect then function to have been called and a return given
self.assertEqual(return_value, ['function_1', 'function_1'], 'A return value list is provided and matches')
assert return_value == ['function_1', 'function_1'], 'A return value list is provided and matches'
# WHEN: I execute the a 2nd function with the different reference and execute the function
Registry().register_function('test2', self.dummy_function_2)
return_value = Registry().execute('test2')
# THEN: I expect then function to have been called and a return given
self.assertEqual(return_value[0], 'function_2', 'A return value is provided and matches')
assert return_value[0] == 'function_2', 'A return value is provided and matches'
def test_registry_working_flags(self):
"""
@ -107,28 +107,28 @@ class TestRegistry(TestCase):
# THEN: we should be able retrieve the saved component
temp = Registry().get_flag('test1')
self.assertEquals(temp, my_data, 'The value should have been saved')
assert temp == my_data, 'The value should have been saved'
# WHEN: I add a component for the second time I am not mad.
# THEN and I will not get an exception
Registry().set_flag('test1', my_data2)
temp = Registry().get_flag('test1')
self.assertEquals(temp, my_data2, 'The value should have been updated')
assert temp == my_data2, 'The value should have been updated'
# WHEN I try to get back a non existent Working Flag
# THEN I will get an exception
with self.assertRaises(KeyError) as context1:
temp = Registry().get_flag('test2')
self.assertEqual(context1.exception.args[0], 'Working Flag test2 not found in list',
'KeyError exception should have been thrown for missing working flag')
assert context1.exception.args[0] == 'Working Flag test2 not found in list', \
'KeyError exception should have been thrown for missing working flag'
# WHEN I try to replace a working flag I should be allowed
Registry().remove_flag('test1')
# THEN I will get an exception
with self.assertRaises(KeyError) as context:
temp = Registry().get_flag('test1')
self.assertEqual(context.exception.args[0], 'Working Flag test1 not found in list',
'KeyError exception should have been thrown for duplicate working flag')
assert context.exception.args[0] == 'Working Flag test1 not found in list', \
'KeyError exception should have been thrown for duplicate working flag'
def test_remove_function(self):
"""
@ -142,7 +142,7 @@ class TestRegistry(TestCase):
Registry().remove_function('test1', self.dummy_function_1)
# THEN: The method should not be available.
assert not Registry().functions_list['test1'], 'The function should not be in the dict anymore.'
assert Registry().functions_list['test1'] == [], 'The function should not be in the dict anymore.'
def dummy_function_1(self):
return "function_1"
@ -174,7 +174,7 @@ class TestRegistryBase(TestCase):
PlainStub()
# THEN: Nothing is registered with the registry
self.assertEqual(len(Registry().functions_list), 0), 'The function should not be in the dict anymore.'
assert len(Registry().functions_list) == 0, 'The function should not be in the dict anymore.'
def test_registry_mixin_present(self):
"""
@ -187,4 +187,4 @@ class TestRegistryBase(TestCase):
RegistryStub()
# THEN: The bootstrap methods should be registered
self.assertEqual(len(Registry().functions_list), 2), 'The bootstrap functions should be in the dict.'
assert len(Registry().functions_list) == 2, 'The bootstrap functions should be in the dict.'

11
tests/functional/openlp_core/common/test_settings.py
View File

@ -139,13 +139,13 @@ class TestSettings(TestCase, TestMixin):
extend = settings.value('extend')
# THEN the default value is returned
self.assertEqual('very wide', extend, 'The default value defined should be returned')
assert 'very wide' == extend, 'The default value defined should be returned'
# WHEN a new value is saved into config
Settings().setValue('test/extend', 'very short')
# THEN the new value is returned when re-read
self.assertEqual('very short', Settings().value('test/extend'), 'The saved value should be returned')
assert 'very short' == Settings().value('test/extend'), 'The saved value should be returned'
def test_settings_nonexisting(self):
"""Test the Settings on query for non-existing value"""
@ -155,7 +155,7 @@ class TestSettings(TestCase, TestMixin):
Settings().value('core/does not exists')
# THEN: An exception with the non-existing key should be thrown
self.assertEqual(str(cm.exception), "'core/does not exists'", 'We should get an exception')
assert str(cm.exception) == "'core/does not exists'", 'We should get an exception'
def test_extend_default_settings(self):
"""Test that the extend_default_settings method extends the default settings"""
@ -167,9 +167,8 @@ class TestSettings(TestCase, TestMixin):
Settings.extend_default_settings({'test/setting 3': 4, 'test/extended 1': 1, 'test/extended 2': 2})
# THEN: The _default_settings__ dictionary_ should have the new keys
self.assertEqual(
Settings.__default_settings__, {'test/setting 1': 1, 'test/setting 2': 2, 'test/setting 3': 4,
'test/extended 1': 1, 'test/extended 2': 2})
assert Settings.__default_settings__ == {'test/setting 1': 1, 'test/setting 2': 2, 'test/setting 3': 4,
'test/extended 1': 1, 'test/extended 2': 2}
@patch('openlp.core.common.settings.QtCore.QSettings.contains')
@patch('openlp.core.common.settings.QtCore.QSettings.value')

2
tests/functional/openlp_core/ui/test_mainwindow.py
View File

@ -106,7 +106,7 @@ class TestMainWindow(TestCase, TestMixin):
self.main_window.open_cmd_line_files("")
# THEN the file should not be opened
assert not mocked_load_file.called, 'load_file should not have been called'
assert mocked_load_file.called is False, 'load_file should not have been called'
def test_main_window_title(self):
"""