From d2ba2ad599a1e47b6021ed9f1e1ec3b8828a7e8a Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 9 Dec 2017 15:00:39 +0000
Subject: [PATCH 01/12] First attempt

---
 tests/functional/openlp_core/api/http/test_error.py | 8 ++++----
 tests/functional/openlp_core/api/http/test_http.py  | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/functional/openlp_core/api/http/test_error.py b/tests/functional/openlp_core/api/http/test_error.py
index 1a694705c..599ecfc03 100644
--- a/tests/functional/openlp_core/api/http/test_error.py
+++ b/tests/functional/openlp_core/api/http/test_error.py
@@ -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'
diff --git a/tests/functional/openlp_core/api/http/test_http.py b/tests/functional/openlp_core/api/http/test_http.py
index ed584c1b9..c3cd1d1f4 100644
--- a/tests/functional/openlp_core/api/http/test_http.py
+++ b/tests/functional/openlp_core/api/http/test_http.py
@@ -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 == 0, '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 == 1, 'The http thread should not have been called'

From 02df3149c722fe00dab50572b094e58c758b6215 Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 9 Dec 2017 15:21:59 +0000
Subject: [PATCH 02/12] First attempt 2

---
 .../openlp_core/api/http/test_http.py         |  4 +--
 .../openlp_core/api/http/test_wsgiapp.py      |  6 ++--
 .../functional/openlp_core/api/test_deploy.py |  2 +-
 tests/functional/openlp_core/api/test_tab.py  | 23 +++++++-------
 .../openlp_core/api/test_websockets.py        | 31 +++++++++----------
 5 files changed, 32 insertions(+), 34 deletions(-)

diff --git a/tests/functional/openlp_core/api/http/test_http.py b/tests/functional/openlp_core/api/http/test_http.py
index c3cd1d1f4..7dd8418ae 100644
--- a/tests/functional/openlp_core/api/http/test_http.py
+++ b/tests/functional/openlp_core/api/http/test_http.py
@@ -54,7 +54,7 @@ class TestHttpServer(TestCase):
 
         # THEN: the api environment should have been created
         assert mock_qthread.call_count == 1, 'The qthread should have been called once'
-        assert mock_thread.call_count == 0, 'The http thread 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')
@@ -69,4 +69,4 @@ class TestHttpServer(TestCase):
 
         # THEN: the api environment should have been created
         assert mock_qthread.call_count == 0, 'The qthread should not have have been called'
-        assert mock_thread.call_count == 1, 'The http thread should not have been called'
+        assert mock_thread.call_count == 0, 'The http thread should not have been called'
diff --git a/tests/functional/openlp_core/api/http/test_wsgiapp.py b/tests/functional/openlp_core/api/http/test_wsgiapp.py
index aff27404a..17b3ae8c5 100644
--- a/tests/functional/openlp_core/api/http/test_wsgiapp.py
+++ b/tests/functional/openlp_core/api/http/test_wsgiapp.py
@@ -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')
diff --git a/tests/functional/openlp_core/api/test_deploy.py b/tests/functional/openlp_core/api/test_deploy.py
index 702e2a35d..0aaf1308b 100644
--- a/tests/functional/openlp_core/api/test_deploy.py
+++ b/tests/functional/openlp_core/api/test_deploy.py
@@ -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'
diff --git a/tests/functional/openlp_core/api/test_tab.py b/tests/functional/openlp_core/api/test_tab.py
index f3c4f31e6..1601c223b 100644
--- a/tests/functional/openlp_core/api/test_tab.py
+++ b/tests/functional/openlp_core/api/test_tab.py
@@ -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'
diff --git a/tests/functional/openlp_core/api/test_websockets.py b/tests/functional/openlp_core/api/test_websockets.py
index f400c50a5..7cc3f376c 100644
--- a/tests/functional/openlp_core/api/test_websockets.py
+++ b/tests/functional/openlp_core/api/test_websockets.py
@@ -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'], 'The blank return value should be True'
+        assert poll_json['results']['theme'], 'The theme return value should be False'
+        assert poll_json['results']['display'], 'The display return value should be False'
+        assert poll_json['results']['isSecure'], 'The isSecure return value should be False'
+        assert poll_json['results']['isAuthorised'], 'The isAuthorised return value should be False'
+        assert poll_json['results']['twelve'], 'The twelve return value should be False'
+        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'

From 3a9d2f6a61c444cdbb3e669e2ca6ad6af0a7527e Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 9 Dec 2017 15:28:09 +0000
Subject: [PATCH 03/12] Fix test

---
 tests/functional/openlp_core/api/test_tab.py        |  2 +-
 tests/functional/openlp_core/api/test_websockets.py | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/functional/openlp_core/api/test_tab.py b/tests/functional/openlp_core/api/test_tab.py
index 1601c223b..fe0f3a81b 100644
--- a/tests/functional/openlp_core/api/test_tab.py
+++ b/tests/functional/openlp_core/api/test_tab.py
@@ -81,7 +81,7 @@ 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
-        assert re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}') == ip_address, \
+        assert (re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'), ip_address) is True, \
             'The return value should be a valid ip address'
 
     def test_get_ip_address_with_ip(self):
diff --git a/tests/functional/openlp_core/api/test_websockets.py b/tests/functional/openlp_core/api/test_websockets.py
index 7cc3f376c..d09aac143 100644
--- a/tests/functional/openlp_core/api/test_websockets.py
+++ b/tests/functional/openlp_core/api/test_websockets.py
@@ -129,12 +129,12 @@ 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
-        assert poll_json['results']['blank'], 'The blank return value should be True'
-        assert poll_json['results']['theme'], 'The theme return value should be False'
-        assert poll_json['results']['display'], 'The display return value should be False'
-        assert poll_json['results']['isSecure'], 'The isSecure return value should be False'
-        assert poll_json['results']['isAuthorised'], 'The isAuthorised return value should be False'
-        assert poll_json['results']['twelve'], 'The twelve return value should be False'
+        assert poll_json['results']['blank'] is False, '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 False'
         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'

From ed2b87aed3893d1ce40dc4e4e3405b5f467ab96f Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 9 Dec 2017 15:32:05 +0000
Subject: [PATCH 04/12] Fix tests

---
 tests/functional/openlp_core/api/test_tab.py        | 2 +-
 tests/functional/openlp_core/api/test_websockets.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/functional/openlp_core/api/test_tab.py b/tests/functional/openlp_core/api/test_tab.py
index fe0f3a81b..2c47776f8 100644
--- a/tests/functional/openlp_core/api/test_tab.py
+++ b/tests/functional/openlp_core/api/test_tab.py
@@ -81,7 +81,7 @@ 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
-        assert (re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'), ip_address) is True, \
+        assert re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', ip_address) is True, \
             'The return value should be a valid ip address'
 
     def test_get_ip_address_with_ip(self):
diff --git a/tests/functional/openlp_core/api/test_websockets.py b/tests/functional/openlp_core/api/test_websockets.py
index d09aac143..8fa1411b8 100644
--- a/tests/functional/openlp_core/api/test_websockets.py
+++ b/tests/functional/openlp_core/api/test_websockets.py
@@ -129,12 +129,12 @@ 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
-        assert poll_json['results']['blank'] is False, 'The blank return value should be True'
+        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 False'
+        assert poll_json['results']['twelve'] is False, 'The twelve return value should be False'
         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'

From 0c8217f33c42fc55f61fb57fa1c18111a84f88e5 Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 9 Dec 2017 15:34:16 +0000
Subject: [PATCH 05/12] Fix tests

---
 tests/functional/openlp_core/api/test_websockets.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/functional/openlp_core/api/test_websockets.py b/tests/functional/openlp_core/api/test_websockets.py
index 8fa1411b8..7da90123d 100644
--- a/tests/functional/openlp_core/api/test_websockets.py
+++ b/tests/functional/openlp_core/api/test_websockets.py
@@ -134,7 +134,7 @@ class TestWSServer(TestCase, TestMixin):
         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 False, 'The twelve 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'

From 595ae30cd4e5ec55db2f54a41bcdfad6010cc044 Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 9 Dec 2017 15:39:31 +0000
Subject: [PATCH 06/12] Fix tests

---
 tests/functional/openlp_core/api/test_tab.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/functional/openlp_core/api/test_tab.py b/tests/functional/openlp_core/api/test_tab.py
index 2c47776f8..bd701784d 100644
--- a/tests/functional/openlp_core/api/test_tab.py
+++ b/tests/functional/openlp_core/api/test_tab.py
@@ -81,7 +81,7 @@ 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
-        assert re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', ip_address) is True, \
+        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):

From 17b70f0c0af44bddc3200c4008d43da318a39cf1 Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 9 Dec 2017 16:11:45 +0000
Subject: [PATCH 07/12] Fix tests

---
 .../openlp_core/common/test_actions.py        | 34 ++++++-------
 .../openlp_core/common/test_common.py         | 35 ++++++-------
 .../openlp_core/common/test_httputils.py      | 10 ++--
 .../openlp_core/common/test_init.py           | 51 +++++++++----------
 4 files changed, 65 insertions(+), 65 deletions(-)

diff --git a/tests/functional/openlp_core/common/test_actions.py b/tests/functional/openlp_core/common/test_actions.py
index 57905654d..d5d1abcf0 100644
--- a/tests/functional/openlp_core/common/test_actions.py
+++ b/tests/functional/openlp_core/common/test_actions.py
@@ -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] == self.action1
+        assert local_list[1] == 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)
diff --git a/tests/functional/openlp_core/common/test_common.py b/tests/functional/openlp_core/common/test_common.py
index 1d817ee90..334ceb21b 100644
--- a/tests/functional/openlp_core/common/test_common.py
+++ b/tests/functional/openlp_core/common/test_common.py
@@ -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_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_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_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'
diff --git a/tests/functional/openlp_core/common/test_httputils.py b/tests/functional/openlp_core/common/test_httputils.py
index 5e7a396b2..ad1ab6e46 100644
--- a/tests/functional/openlp_core/common/test_httputils.py
+++ b/tests/functional/openlp_core/common/test_httputils.py
@@ -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, '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')
diff --git a/tests/functional/openlp_core/common/test_init.py b/tests/functional/openlp_core/common/test_init.py
index 9b86c99aa..fbeaec957 100644
--- a/tests/functional/openlp_core/common/test_init.py
+++ b/tests/functional/openlp_core/common/test_init.py
@@ -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 not result, "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, '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, '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 not result

From ac95f4e3cad395ee79d5b597df5143087698e4c6 Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 9 Dec 2017 16:29:58 +0000
Subject: [PATCH 08/12] Finish common

---
 .../openlp_core/common/test_json.py           | 12 +++----
 .../openlp_core/common/test_mixins.py         |  8 ++---
 .../openlp_core/common/test_path.py           | 34 +++++++++----------
 .../common/test_projector_utilities.py        | 26 +++++++-------
 .../openlp_core/common/test_registry.py       | 30 ++++++++--------
 .../openlp_core/common/test_settings.py       | 11 +++---
 6 files changed, 60 insertions(+), 61 deletions(-)

diff --git a/tests/functional/openlp_core/common/test_json.py b/tests/functional/openlp_core/common/test_json.py
index 3b0631dc4..392b30c9b 100644
--- a/tests/functional/openlp_core/common/test_json.py
+++ b/tests/functional/openlp_core/common/test_json.py
@@ -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 not mocked_path.called
 
     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"]}]'
diff --git a/tests/functional/openlp_core/common/test_mixins.py b/tests/functional/openlp_core/common/test_mixins.py
index 8eee60c6f..db9606d4e 100644
--- a/tests/functional/openlp_core/common/test_mixins.py
+++ b/tests/functional/openlp_core/common/test_mixins.py
@@ -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 not self.application, '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')
diff --git a/tests/functional/openlp_core/common/test_path.py b/tests/functional/openlp_core/common/test_path.py
index 498b7aaa0..d7c20ab6f 100644
--- a/tests/functional/openlp_core/common/test_path.py
+++ b/tests/functional/openlp_core/common/test_path.py
@@ -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):
         """
@@ -182,7 +182,7 @@ class TestShutil(TestCase):
             # 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)
+            assert not result
 
     def test_rmtree_optional_params(self):
         """
@@ -214,7 +214,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 not result
 
     def test_which_command(self):
         """
@@ -230,7 +230,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 +257,7 @@ class TestPath(TestCase):
         result = path_to_str(None)
 
         # THEN: `path_to_str` should return an empty string
-        self.assertEqual(result, '')
+        assert not result
 
     def test_path_to_str_path_object(self):
         """
@@ -268,7 +268,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 +289,7 @@ class TestPath(TestCase):
         result = str_to_path('')
 
         # THEN: `path_to_str` should return None
-        self.assertEqual(result, None)
+        assert not result
 
     def test_path_encode_json(self):
         """
@@ -301,7 +301,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 +313,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 +326,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 +340,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):
         """
diff --git a/tests/functional/openlp_core/common/test_projector_utilities.py b/tests/functional/openlp_core/common/test_projector_utilities.py
index cbdfec238..45e13c04d 100644
--- a/tests/functional/openlp_core/common/test_projector_utilities.py
+++ b/tests/functional/openlp_core/common/test_projector_utilities.py
@@ -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, '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, '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 not valid, '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, '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, '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 not valid, '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'
diff --git a/tests/functional/openlp_core/common/test_registry.py b/tests/functional/openlp_core/common/test_registry.py
index a274243bd..81b4230a1 100644
--- a/tests/functional/openlp_core/common/test_registry.py
+++ b/tests/functional/openlp_core/common/test_registry.py
@@ -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 not temp, '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 not temp, '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):
         """
@@ -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.'
diff --git a/tests/functional/openlp_core/common/test_settings.py b/tests/functional/openlp_core/common/test_settings.py
index ff6ee8765..4cad58af0 100644
--- a/tests/functional/openlp_core/common/test_settings.py
+++ b/tests/functional/openlp_core/common/test_settings.py
@@ -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')

From c25a446839a075f434905c9b3186bc990160f7f4 Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 9 Dec 2017 16:37:26 +0000
Subject: [PATCH 09/12] Finish common again

---
 tests/functional/openlp_core/common/test_common.py | 2 +-
 tests/functional/openlp_core/common/test_path.py   | 5 ++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/tests/functional/openlp_core/common/test_common.py b/tests/functional/openlp_core/common/test_common.py
index 334ceb21b..5ffc664cd 100644
--- a/tests/functional/openlp_core/common/test_common.py
+++ b/tests/functional/openlp_core/common/test_common.py
@@ -70,7 +70,7 @@ 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')])
+                                                   call('openlp.import_dir.file4')])
 
     def test_extension_loader_import_error(self):
         """
diff --git a/tests/functional/openlp_core/common/test_path.py b/tests/functional/openlp_core/common/test_path.py
index d7c20ab6f..42d78cc7e 100644
--- a/tests/functional/openlp_core/common/test_path.py
+++ b/tests/functional/openlp_core/common/test_path.py
@@ -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)
-            assert not result
 
     def test_rmtree_optional_params(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
-        assert result ==  os.path.join('test', 'path')
+        assert result == os.path.join('test', 'path')
 
     def test_str_to_path_type_error(self):
         """

From ca936f5e1a3bf8fd1e877964a249a4c941fd1b4c Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Fri, 15 Dec 2017 16:19:42 +0000
Subject: [PATCH 10/12] fixes

---
 tests/functional/openlp_core/common/test_actions.py         | 4 ++--
 tests/functional/openlp_core/common/test_httputils.py       | 2 +-
 tests/functional/openlp_core/common/test_init.py            | 6 +++---
 tests/functional/openlp_core/common/test_json.py            | 2 +-
 tests/functional/openlp_core/common/test_mixins.py          | 2 +-
 tests/functional/openlp_core/common/test_path.py            | 6 +++---
 .../openlp_core/common/test_projector_utilities.py          | 6 +++---
 tests/functional/openlp_core/common/test_registry.py        | 6 +++---
 tests/functional/openlp_core/ui/test_mainwindow.py          | 2 +-
 9 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/tests/functional/openlp_core/common/test_actions.py b/tests/functional/openlp_core/common/test_actions.py
index d5d1abcf0..7d5ac6fca 100644
--- a/tests/functional/openlp_core/common/test_actions.py
+++ b/tests/functional/openlp_core/common/test_actions.py
@@ -124,8 +124,8 @@ class TestCategoryActionList(TestCase):
         local_list = [a for a in self.list]
         # THEN: Make sure they are returned in correct order
         assert len(self.list) == 2
-        assert local_list[0] == self.action1
-        assert local_list[1] == self.action2
+        assert local_list[0] is self.action1
+        assert local_list[1] is self.action2
 
     def test_remove(self):
         """
diff --git a/tests/functional/openlp_core/common/test_httputils.py b/tests/functional/openlp_core/common/test_httputils.py
index ad1ab6e46..0b39033d9 100644
--- a/tests/functional/openlp_core/common/test_httputils.py
+++ b/tests/functional/openlp_core/common/test_httputils.py
@@ -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'
diff --git a/tests/functional/openlp_core/common/test_init.py b/tests/functional/openlp_core/common/test_init.py
index fbeaec957..5292f414e 100644
--- a/tests/functional/openlp_core/common/test_init.py
+++ b/tests/functional/openlp_core/common/test_init.py
@@ -258,7 +258,7 @@ class TestInit(TestCase, TestMixin):
         result = delete_file(None)
 
         # THEN: delete_file should return False
-        assert not 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):
         """
@@ -271,7 +271,7 @@ class TestInit(TestCase, TestMixin):
             result = delete_file(Path('path', 'file.ext'))
 
             # THEN: delete_file should return True
-            assert 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):
         """
@@ -363,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')
-            assert not result
+            assert result is None
diff --git a/tests/functional/openlp_core/common/test_json.py b/tests/functional/openlp_core/common/test_json.py
index 392b30c9b..18cba3b4e 100644
--- a/tests/functional/openlp_core/common/test_json.py
+++ b/tests/functional/openlp_core/common/test_json.py
@@ -60,7 +60,7 @@ class TestOpenLPJsonDecoder(TestCase):
 
             # THEN: The object should be returned unchanged and a Path object should not have been initiated
             assert result == {'key': 'value'}
-            assert not mocked_path.called
+            assert mocked_path.called is False
 
     def test_json_decode(self):
         """
diff --git a/tests/functional/openlp_core/common/test_mixins.py b/tests/functional/openlp_core/common/test_mixins.py
index db9606d4e..f49c2b797 100644
--- a/tests/functional/openlp_core/common/test_mixins.py
+++ b/tests/functional/openlp_core/common/test_mixins.py
@@ -46,7 +46,7 @@ class TestRegistryProperties(TestCase, RegistryProperties):
         # GIVEN an Empty Registry
         # WHEN there is no Application
         # THEN the application should be none
-        assert not self.application, 'The application value should be None'
+        assert self.application is None, 'The application value should be None'
 
     def test_application(self):
         """
diff --git a/tests/functional/openlp_core/common/test_path.py b/tests/functional/openlp_core/common/test_path.py
index 42d78cc7e..b069c251d 100644
--- a/tests/functional/openlp_core/common/test_path.py
+++ b/tests/functional/openlp_core/common/test_path.py
@@ -213,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')
-            assert not result
+        assert result is None
 
     def test_which_command(self):
         """
@@ -256,7 +256,7 @@ class TestPath(TestCase):
         result = path_to_str(None)
 
         # THEN: `path_to_str` should return an empty string
-        assert not result
+        assert result == ''
 
     def test_path_to_str_path_object(self):
         """
@@ -288,7 +288,7 @@ class TestPath(TestCase):
         result = str_to_path('')
 
         # THEN: `path_to_str` should return None
-        assert not result
+        assert result is None
 
     def test_path_encode_json(self):
         """
diff --git a/tests/functional/openlp_core/common/test_projector_utilities.py b/tests/functional/openlp_core/common/test_projector_utilities.py
index 45e13c04d..db163c152 100644
--- a/tests/functional/openlp_core/common/test_projector_utilities.py
+++ b/tests/functional/openlp_core/common/test_projector_utilities.py
@@ -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
     """
@@ -87,7 +87,7 @@ class testProjectorUtilities(TestCase):
         valid = verify_ip_address(addr=ip4_bad)
 
         # THEN: Verify we received True
-        assert not 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):
         """
@@ -117,7 +117,7 @@ class testProjectorUtilities(TestCase):
         valid = verify_ip_address(addr=ip6_bad)
 
         # THEN: Validate bad return
-        assert not valid, 'IPv6 bad address should have been invalid'
+        assert valid is False, 'IPv6 bad address should have been invalid'
 
     def test_md5_hash(self):
         """
diff --git a/tests/functional/openlp_core/common/test_registry.py b/tests/functional/openlp_core/common/test_registry.py
index 81b4230a1..7e8a80e14 100644
--- a/tests/functional/openlp_core/common/test_registry.py
+++ b/tests/functional/openlp_core/common/test_registry.py
@@ -57,13 +57,13 @@ class TestRegistry(TestCase):
         # WHEN I try to get back a non existent component
         # THEN I will get an exception
         temp = Registry().get('test2')
-        assert not temp, 'None should have been returned for missing service'
+        assert temp is False, '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')
-        assert not temp, 'None should have been returned for deleted service'
+        assert temp is False, 'None should have been returned for deleted service'
 
     def test_registry_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'] is None, 'The function should not be in the dict anymore.'
 
     def dummy_function_1(self):
         return "function_1"
diff --git a/tests/functional/openlp_core/ui/test_mainwindow.py b/tests/functional/openlp_core/ui/test_mainwindow.py
index 4a0404eab..9dee80c0d 100644
--- a/tests/functional/openlp_core/ui/test_mainwindow.py
+++ b/tests/functional/openlp_core/ui/test_mainwindow.py
@@ -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):
         """

From eb208380469ad0cc4ebff7bd19b96a2ba6add226 Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Fri, 15 Dec 2017 16:30:10 +0000
Subject: [PATCH 11/12] fixes

---
 tests/functional/openlp_core/common/test_registry.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/functional/openlp_core/common/test_registry.py b/tests/functional/openlp_core/common/test_registry.py
index 7e8a80e14..6f3cc5752 100644
--- a/tests/functional/openlp_core/common/test_registry.py
+++ b/tests/functional/openlp_core/common/test_registry.py
@@ -57,13 +57,13 @@ class TestRegistry(TestCase):
         # WHEN I try to get back a non existent component
         # THEN I will get an exception
         temp = Registry().get('test2')
-        assert temp is False, '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')
-        assert temp is False, '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):
         """
@@ -142,7 +142,7 @@ class TestRegistry(TestCase):
         Registry().remove_function('test1', self.dummy_function_1)
 
         # THEN: The method should not be available.
-        assert Registry().functions_list['test1'] is None, '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"

From efe7129f214ce37b5c4875e6ad3bdb6fa88c5e7f Mon Sep 17 00:00:00 2001
From: Tim Bentley <tim.bentley@gmail.com>
Date: Sat, 16 Dec 2017 08:43:33 +0000
Subject: [PATCH 12/12] fixes

---
 tests/functional/openlp_core/common/test_common.py        | 6 +++---
 tests/functional/openlp_core/common/test_httputils.py     | 2 +-
 tests/functional/openlp_core/common/test_init.py          | 4 ++--
 .../openlp_core/common/test_projector_utilities.py        | 8 ++++----
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/functional/openlp_core/common/test_common.py b/tests/functional/openlp_core/common/test_common.py
index 5ffc664cd..368705821 100644
--- a/tests/functional/openlp_core/common/test_common.py
+++ b/tests/functional/openlp_core/common/test_common.py
@@ -175,7 +175,7 @@ class TestCommonFunctions(TestCase):
             mocked_sys.platform = 'win32'
 
             # THEN: The three platform functions should perform properly
-            assert is_win(), 'is_win() should return True'
+            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'
 
@@ -191,7 +191,7 @@ class TestCommonFunctions(TestCase):
             mocked_sys.platform = 'darwin'
 
             # THEN: The three platform functions should perform properly
-            assert is_macosx(), 'is_macosx() should return True'
+            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'
 
@@ -207,7 +207,7 @@ class TestCommonFunctions(TestCase):
             mocked_sys.platform = 'linux3'
 
             # THEN: The three platform functions should perform properly
-            assert is_linux(), 'is_linux() should return True'
+            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'
 
diff --git a/tests/functional/openlp_core/common/test_httputils.py b/tests/functional/openlp_core/common/test_httputils.py
index 0b39033d9..b7c08993f 100644
--- a/tests/functional/openlp_core/common/test_httputils.py
+++ b/tests/functional/openlp_core/common/test_httputils.py
@@ -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
-            assert 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):
         """
diff --git a/tests/functional/openlp_core/common/test_init.py b/tests/functional/openlp_core/common/test_init.py
index 5292f414e..9965a07ee 100644
--- a/tests/functional/openlp_core/common/test_init.py
+++ b/tests/functional/openlp_core/common/test_init.py
@@ -286,7 +286,7 @@ class TestInit(TestCase, TestMixin):
 
             # THEN: The function should not attempt to delete the file and it should return True
             assert mocked_unlink.called is False
-            assert result, 'delete_file should return True when the file doesnt exist'
+            assert result is True, 'delete_file should return True when the file doesnt exist'
 
     def test_delete_file_path_exception(self):
         """
@@ -346,7 +346,7 @@ class TestInit(TestCase, TestMixin):
             mocked_open.assert_called_once_with('rb')
             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()
-            assert result, encoding_result
+            assert result == encoding_result
 
     def test_get_file_encoding_oserror(self):
         """
diff --git a/tests/functional/openlp_core/common/test_projector_utilities.py b/tests/functional/openlp_core/common/test_projector_utilities.py
index db163c152..5a3f886cf 100644
--- a/tests/functional/openlp_core/common/test_projector_utilities.py
+++ b/tests/functional/openlp_core/common/test_projector_utilities.py
@@ -67,7 +67,7 @@ class TestProjectorUtilities(TestCase):
         valid = verify_ip_address(addr=ip4_local)
 
         # THEN: Verify we received True
-        assert 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
-        assert 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):
         """
@@ -97,7 +97,7 @@ class TestProjectorUtilities(TestCase):
         valid = verify_ip_address(addr=ip6_loopback)
 
         # THEN: Validate return
-        assert 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
-        assert 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):
         """