Fixed E128 flake8 warnings in tests/.

6 files changed, 270 insertions, 243 deletions

diff --git a/tests/utils_tests/test_dateparse.py b/tests/utils_tests/test_dateparse.py
index f0585187fc..bf740a9cc5 100644
--- a/tests/utils_tests/test_dateparse.py
+++ b/tests/utils_tests/test_dateparse.py
@@ -33,20 +33,34 @@ class DateParseTests(unittest.TestCase):
 
     def test_parse_datetime(self):
         # Valid inputs
-        self.assertEqual(parse_datetime('2012-04-23T09:15:00'),
-            datetime(2012, 4, 23, 9, 15))
-        self.assertEqual(parse_datetime('2012-4-9 4:8:16'),
-            datetime(2012, 4, 9, 4, 8, 16))
-        self.assertEqual(parse_datetime('2012-04-23T09:15:00Z'),
-            datetime(2012, 4, 23, 9, 15, 0, 0, get_fixed_timezone(0)))
-        self.assertEqual(parse_datetime('2012-4-9 4:8:16-0320'),
-            datetime(2012, 4, 9, 4, 8, 16, 0, get_fixed_timezone(-200)))
-        self.assertEqual(parse_datetime('2012-04-23T10:20:30.400+02:30'),
-            datetime(2012, 4, 23, 10, 20, 30, 400000, get_fixed_timezone(150)))
-        self.assertEqual(parse_datetime('2012-04-23T10:20:30.400+02'),
-            datetime(2012, 4, 23, 10, 20, 30, 400000, get_fixed_timezone(120)))
-        self.assertEqual(parse_datetime('2012-04-23T10:20:30.400-02'),
-            datetime(2012, 4, 23, 10, 20, 30, 400000, get_fixed_timezone(-120)))
+        self.assertEqual(
+            parse_datetime('2012-04-23T09:15:00'),
+            datetime(2012, 4, 23, 9, 15)
+        )
+        self.assertEqual(
+            parse_datetime('2012-4-9 4:8:16'),
+            datetime(2012, 4, 9, 4, 8, 16)
+        )
+        self.assertEqual(
+            parse_datetime('2012-04-23T09:15:00Z'),
+            datetime(2012, 4, 23, 9, 15, 0, 0, get_fixed_timezone(0))
+        )
+        self.assertEqual(
+            parse_datetime('2012-4-9 4:8:16-0320'),
+            datetime(2012, 4, 9, 4, 8, 16, 0, get_fixed_timezone(-200))
+        )
+        self.assertEqual(
+            parse_datetime('2012-04-23T10:20:30.400+02:30'),
+            datetime(2012, 4, 23, 10, 20, 30, 400000, get_fixed_timezone(150))
+        )
+        self.assertEqual(
+            parse_datetime('2012-04-23T10:20:30.400+02'),
+            datetime(2012, 4, 23, 10, 20, 30, 400000, get_fixed_timezone(120))
+        )
+        self.assertEqual(
+            parse_datetime('2012-04-23T10:20:30.400-02'),
+            datetime(2012, 4, 23, 10, 20, 30, 400000, get_fixed_timezone(-120))
+        )
         # Invalid inputs
         self.assertEqual(parse_datetime('20120423091500'), None)
         with self.assertRaises(ValueError):
diff --git a/tests/utils_tests/test_encoding.py b/tests/utils_tests/test_encoding.py
index 49fe33669f..5ddb18d069 100644
--- a/tests/utils_tests/test_encoding.py
+++ b/tests/utils_tests/test_encoding.py
@@ -80,10 +80,11 @@ class TestEncodingUtils(unittest.TestCase):
 class TestRFC3987IEncodingUtils(unittest.TestCase):
 
     def test_filepath_to_uri(self):
-        self.assertEqual(filepath_to_uri('upload\\чубака.mp4'),
-            'upload/%D1%87%D1%83%D0%B1%D0%B0%D0%BA%D0%B0.mp4')
-        self.assertEqual(filepath_to_uri('upload\\чубака.mp4'.encode('utf-8')),
-            'upload/%D1%87%D1%83%D0%B1%D0%B0%D0%BA%D0%B0.mp4')
+        self.assertEqual(filepath_to_uri('upload\\чубака.mp4'), 'upload/%D1%87%D1%83%D0%B1%D0%B0%D0%BA%D0%B0.mp4')
+        self.assertEqual(
+            filepath_to_uri('upload\\чубака.mp4'.encode('utf-8')),
+            'upload/%D1%87%D1%83%D0%B1%D0%B0%D0%BA%D0%B0.mp4'
+        )
 
     def test_iri_to_uri(self):
         cases = [
diff --git a/tests/utils_tests/test_http.py b/tests/utils_tests/test_http.py
index 8f93c472a7..e22f76be2e 100644
--- a/tests/utils_tests/test_http.py
+++ b/tests/utils_tests/test_http.py
@@ -78,42 +78,49 @@ class TestUtilsHttp(unittest.TestCase):
             self.assertEqual(http.base36_to_int(b36), n)
 
     def test_is_safe_url(self):
-        for bad_url in ('http://example.com',
-                        'http:///example.com',
-                        'https://example.com',
-                        'ftp://example.com',
-                        r'\\example.com',
-                        r'\\\example.com',
-                        r'/\\/example.com',
-                        r'\\\example.com',
-                        r'\\example.com',
-                        r'\\//example.com',
-                        r'/\/example.com',
-                        r'\/example.com',
-                        r'/\example.com',
-                        'http:///example.com',
-                        'http:/\//example.com',
-                        'http:\/example.com',
-                        'http:/\example.com',
-                        'javascript:alert("XSS")',
-                        '\njavascript:alert(x)',
-                        '\x08//example.com',
-                        r'http://otherserver\@example.com',
-                        r'http:\\testserver\@example.com',
-                        r'http://testserver\me:pass@example.com',
-                        r'http://testserver\@example.com',
-                        r'http:\\testserver\confirm\me@example.com',
-                        '\n'):
+        bad_urls = (
+            'http://example.com',
+            'http:///example.com',
+            'https://example.com',
+            'ftp://example.com',
+            r'\\example.com',
+            r'\\\example.com',
+            r'/\\/example.com',
+            r'\\\example.com',
+            r'\\example.com',
+            r'\\//example.com',
+            r'/\/example.com',
+            r'\/example.com',
+            r'/\example.com',
+            'http:///example.com',
+            'http:/\//example.com',
+            'http:\/example.com',
+            'http:/\example.com',
+            'javascript:alert("XSS")',
+            '\njavascript:alert(x)',
+            '\x08//example.com',
+            r'http://otherserver\@example.com',
+            r'http:\\testserver\@example.com',
+            r'http://testserver\me:pass@example.com',
+            r'http://testserver\@example.com',
+            r'http:\\testserver\confirm\me@example.com',
+            '\n',
+        )
+        for bad_url in bad_urls:
             self.assertFalse(http.is_safe_url(bad_url, host='testserver'), "%s should be blocked" % bad_url)
-        for good_url in ('/view/?param=http://example.com',
-                     '/view/?param=https://example.com',
-                     '/view?param=ftp://example.com',
-                     'view/?param=//example.com',
-                     'https://testserver/',
-                     'HTTPS://testserver/',
-                     '//testserver/',
-                     'http://testserver/confirm?email=me@example.com',
-                     '/url%20with%20spaces/'):
+
+        good_urls = (
+            '/view/?param=http://example.com',
+            '/view/?param=https://example.com',
+            '/view?param=ftp://example.com',
+            'view/?param=//example.com',
+            'https://testserver/',
+            'HTTPS://testserver/',
+            '//testserver/',
+            'http://testserver/confirm?email=me@example.com',
+            '/url%20with%20spaces/',
+        )
+        for good_url in good_urls:
             self.assertTrue(http.is_safe_url(good_url, host='testserver'), "%s should be allowed" % good_url)
 
         if six.PY2:
@@ -140,26 +147,14 @@ class TestUtilsHttp(unittest.TestCase):
         self.assertEqual(bytestring, decoded)
 
     def test_urlquote(self):
-        self.assertEqual(http.urlquote('Paris & Orl\xe9ans'),
-            'Paris%20%26%20Orl%C3%A9ans')
-        self.assertEqual(http.urlquote('Paris & Orl\xe9ans', safe="&"),
-            'Paris%20&%20Orl%C3%A9ans')
-        self.assertEqual(
-            http.urlunquote('Paris%20%26%20Orl%C3%A9ans'),
-            'Paris & Orl\xe9ans')
-        self.assertEqual(
-            http.urlunquote('Paris%20&%20Orl%C3%A9ans'),
-            'Paris & Orl\xe9ans')
-        self.assertEqual(http.urlquote_plus('Paris & Orl\xe9ans'),
-            'Paris+%26+Orl%C3%A9ans')
-        self.assertEqual(http.urlquote_plus('Paris & Orl\xe9ans', safe="&"),
-            'Paris+&+Orl%C3%A9ans')
-        self.assertEqual(
-            http.urlunquote_plus('Paris+%26+Orl%C3%A9ans'),
-            'Paris & Orl\xe9ans')
-        self.assertEqual(
-            http.urlunquote_plus('Paris+&+Orl%C3%A9ans'),
-            'Paris & Orl\xe9ans')
+        self.assertEqual(http.urlquote('Paris & Orl\xe9ans'), 'Paris%20%26%20Orl%C3%A9ans')
+        self.assertEqual(http.urlquote('Paris & Orl\xe9ans', safe="&"), 'Paris%20&%20Orl%C3%A9ans')
+        self.assertEqual(http.urlunquote('Paris%20%26%20Orl%C3%A9ans'), 'Paris & Orl\xe9ans')
+        self.assertEqual(http.urlunquote('Paris%20&%20Orl%C3%A9ans'), 'Paris & Orl\xe9ans')
+        self.assertEqual(http.urlquote_plus('Paris & Orl\xe9ans'), 'Paris+%26+Orl%C3%A9ans')
+        self.assertEqual(http.urlquote_plus('Paris & Orl\xe9ans', safe="&"), 'Paris+&+Orl%C3%A9ans')
+        self.assertEqual(http.urlunquote_plus('Paris+%26+Orl%C3%A9ans'), 'Paris & Orl\xe9ans')
+        self.assertEqual(http.urlunquote_plus('Paris+&+Orl%C3%A9ans'), 'Paris & Orl\xe9ans')
 
     def test_is_same_domain_good(self):
         for pair in (
@@ -204,15 +199,12 @@ class HttpDateProcessingTests(unittest.TestCase):
 
     def test_parsing_rfc1123(self):
         parsed = http.parse_http_date('Sun, 06 Nov 1994 08:49:37 GMT')
-        self.assertEqual(datetime.utcfromtimestamp(parsed),
-                         datetime(1994, 11, 6, 8, 49, 37))
+        self.assertEqual(datetime.utcfromtimestamp(parsed), datetime(1994, 11, 6, 8, 49, 37))
 
     def test_parsing_rfc850(self):
         parsed = http.parse_http_date('Sunday, 06-Nov-94 08:49:37 GMT')
-        self.assertEqual(datetime.utcfromtimestamp(parsed),
-                         datetime(1994, 11, 6, 8, 49, 37))
+        self.assertEqual(datetime.utcfromtimestamp(parsed), datetime(1994, 11, 6, 8, 49, 37))
 
     def test_parsing_asctime(self):
         parsed = http.parse_http_date('Sun Nov  6 08:49:37 1994')
-        self.assertEqual(datetime.utcfromtimestamp(parsed),
-                         datetime(1994, 11, 6, 8, 49, 37))
+        self.assertEqual(datetime.utcfromtimestamp(parsed), datetime(1994, 11, 6, 8, 49, 37))
diff --git a/tests/utils_tests/test_termcolors.py b/tests/utils_tests/test_termcolors.py
index 6e1aa50124..08e4ae5f5a 100644
--- a/tests/utils_tests/test_termcolors.py
+++ b/tests/utils_tests/test_termcolors.py
@@ -17,45 +17,63 @@ class TermColorTests(unittest.TestCase):
         self.assertEqual(parse_color_setting('nocolor'), None)
 
     def test_fg(self):
-        self.assertEqual(parse_color_setting('error=green'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
+        self.assertEqual(
+            parse_color_setting('error=green'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
 
     def test_fg_bg(self):
-        self.assertEqual(parse_color_setting('error=green/blue'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue'}))
+        self.assertEqual(
+            parse_color_setting('error=green/blue'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue'})
+        )
 
     def test_fg_opts(self):
-        self.assertEqual(parse_color_setting('error=green,blink'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)}))
-
-        self.assertEqual(parse_color_setting('error=green,bold,blink'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink', 'bold')}))
+        self.assertEqual(
+            parse_color_setting('error=green,blink'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)})
+        )
+        self.assertEqual(
+            parse_color_setting('error=green,bold,blink'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink', 'bold')})
+        )
 
     def test_fg_bg_opts(self):
-        self.assertEqual(parse_color_setting('error=green/blue,blink'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue', 'opts': ('blink',)}))
-
-        self.assertEqual(parse_color_setting('error=green/blue,bold,blink'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue', 'opts': ('blink', 'bold')}))
+        self.assertEqual(
+            parse_color_setting('error=green/blue,blink'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue', 'opts': ('blink',)})
+        )
+        self.assertEqual(
+            parse_color_setting('error=green/blue,bold,blink'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue', 'opts': ('blink', 'bold')})
+        )
 
     def test_override_palette(self):
-        self.assertEqual(parse_color_setting('light;error=green'),
-            dict(PALETTES[LIGHT_PALETTE], ERROR={'fg': 'green'}))
+        self.assertEqual(
+            parse_color_setting('light;error=green'),
+            dict(PALETTES[LIGHT_PALETTE], ERROR={'fg': 'green'})
+        )
 
     def test_override_nocolor(self):
-        self.assertEqual(parse_color_setting('nocolor;error=green'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
+        self.assertEqual(
+            parse_color_setting('nocolor;error=green'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
 
     def test_reverse_override(self):
         self.assertEqual(parse_color_setting('error=green;light'), PALETTES[LIGHT_PALETTE])
 
     def test_multiple_roles(self):
-        self.assertEqual(parse_color_setting('error=green;sql_field=blue'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}, SQL_FIELD={'fg': 'blue'}))
+        self.assertEqual(
+            parse_color_setting('error=green;sql_field=blue'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}, SQL_FIELD={'fg': 'blue'})
+        )
 
     def test_override_with_multiple_roles(self):
-        self.assertEqual(parse_color_setting('light;error=green;sql_field=blue'),
-            dict(PALETTES[LIGHT_PALETTE], ERROR={'fg': 'green'}, SQL_FIELD={'fg': 'blue'}))
+        self.assertEqual(
+            parse_color_setting('light;error=green;sql_field=blue'),
+            dict(PALETTES[LIGHT_PALETTE], ERROR={'fg': 'green'}, SQL_FIELD={'fg': 'blue'})
+        )
 
     def test_empty_definition(self):
         self.assertEqual(parse_color_setting(';'), None)
@@ -63,14 +81,18 @@ class TermColorTests(unittest.TestCase):
         self.assertEqual(parse_color_setting(';;;'), None)
 
     def test_empty_options(self):
-        self.assertEqual(parse_color_setting('error=green,'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
-
-        self.assertEqual(parse_color_setting('error=green,,,'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
-
-        self.assertEqual(parse_color_setting('error=green,,blink,,'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)}))
+        self.assertEqual(
+            parse_color_setting('error=green,'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
+        self.assertEqual(
+            parse_color_setting('error=green,,,'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
+        self.assertEqual(
+            parse_color_setting('error=green,,blink,,'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)})
+        )
 
     def test_bad_palette(self):
         self.assertEqual(parse_color_setting('unknown'), None)
@@ -78,60 +100,82 @@ class TermColorTests(unittest.TestCase):
     def test_bad_role(self):
         self.assertEqual(parse_color_setting('unknown='), None)
         self.assertEqual(parse_color_setting('unknown=green'), None)
-        self.assertEqual(parse_color_setting('unknown=green;sql_field=blue'),
-            dict(PALETTES[NOCOLOR_PALETTE], SQL_FIELD={'fg': 'blue'}))
+        self.assertEqual(
+            parse_color_setting('unknown=green;sql_field=blue'),
+            dict(PALETTES[NOCOLOR_PALETTE], SQL_FIELD={'fg': 'blue'})
+        )
 
     def test_bad_color(self):
         self.assertEqual(parse_color_setting('error='), None)
-        self.assertEqual(parse_color_setting('error=;sql_field=blue'),
-            dict(PALETTES[NOCOLOR_PALETTE], SQL_FIELD={'fg': 'blue'}))
-
+        self.assertEqual(
+            parse_color_setting('error=;sql_field=blue'),
+            dict(PALETTES[NOCOLOR_PALETTE], SQL_FIELD={'fg': 'blue'})
+        )
         self.assertEqual(parse_color_setting('error=unknown'), None)
-        self.assertEqual(parse_color_setting('error=unknown;sql_field=blue'),
-            dict(PALETTES[NOCOLOR_PALETTE], SQL_FIELD={'fg': 'blue'}))
-
-        self.assertEqual(parse_color_setting('error=green/unknown'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
-
-        self.assertEqual(parse_color_setting('error=green/blue/something'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue'}))
-
-        self.assertEqual(parse_color_setting('error=green/blue/something,blink'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue', 'opts': ('blink',)}))
+        self.assertEqual(
+            parse_color_setting('error=unknown;sql_field=blue'),
+            dict(PALETTES[NOCOLOR_PALETTE], SQL_FIELD={'fg': 'blue'})
+        )
+        self.assertEqual(
+            parse_color_setting('error=green/unknown'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
+        self.assertEqual(
+            parse_color_setting('error=green/blue/something'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue'})
+        )
+        self.assertEqual(
+            parse_color_setting('error=green/blue/something,blink'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue', 'opts': ('blink',)})
+        )
 
     def test_bad_option(self):
-        self.assertEqual(parse_color_setting('error=green,unknown'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
-
-        self.assertEqual(parse_color_setting('error=green,unknown,blink'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)}))
+        self.assertEqual(
+            parse_color_setting('error=green,unknown'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
+        self.assertEqual(
+            parse_color_setting('error=green,unknown,blink'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)})
+        )
 
     def test_role_case(self):
-        self.assertEqual(parse_color_setting('ERROR=green'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
-
-        self.assertEqual(parse_color_setting('eRrOr=green'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
+        self.assertEqual(
+            parse_color_setting('ERROR=green'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
+        self.assertEqual(
+            parse_color_setting('eRrOr=green'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
 
     def test_color_case(self):
-        self.assertEqual(parse_color_setting('error=GREEN'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
-
-        self.assertEqual(parse_color_setting('error=GREEN/BLUE'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue'}))
-
-        self.assertEqual(parse_color_setting('error=gReEn'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'}))
-
-        self.assertEqual(parse_color_setting('error=gReEn/bLuE'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue'}))
+        self.assertEqual(
+            parse_color_setting('error=GREEN'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
+        self.assertEqual(
+            parse_color_setting('error=GREEN/BLUE'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue'})
+        )
+        self.assertEqual(
+            parse_color_setting('error=gReEn'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green'})
+        )
+        self.assertEqual(
+            parse_color_setting('error=gReEn/bLuE'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'bg': 'blue'})
+        )
 
     def test_opts_case(self):
-        self.assertEqual(parse_color_setting('error=green,BLINK'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)}))
-
-        self.assertEqual(parse_color_setting('error=green,bLiNk'),
-            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)}))
+        self.assertEqual(
+            parse_color_setting('error=green,BLINK'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)})
+        )
+        self.assertEqual(
+            parse_color_setting('error=green,bLiNk'),
+            dict(PALETTES[NOCOLOR_PALETTE], ERROR={'fg': 'green', 'opts': ('blink',)})
+        )
 
     def test_colorize_empty_text(self):
         self.assertEqual(colorize(text=None), '\x1b[m\x1b[0m')
diff --git a/tests/utils_tests/test_text.py b/tests/utils_tests/test_text.py
index 5d97844800..df4c055503 100644
--- a/tests/utils_tests/test_text.py
+++ b/tests/utils_tests/test_text.py
@@ -58,12 +58,9 @@ class TestUtilsText(SimpleTestCase):
         truncator = text.Truncator(
             'The quick brown fox jumped over the lazy dog.'
         )
-        self.assertEqual('The quick brown fox jumped over the lazy dog.',
-            truncator.chars(100)),
-        self.assertEqual('The quick brown fox ...',
-            truncator.chars(23)),
-        self.assertEqual('The quick brown fo.....',
-            truncator.chars(23, '.....')),
+        self.assertEqual('The quick brown fox jumped over the lazy dog.', truncator.chars(100)),
+        self.assertEqual('The quick brown fox ...', truncator.chars(23)),
+        self.assertEqual('The quick brown fo.....', truncator.chars(23, '.....')),
 
         # Ensure that we normalize our unicode data first
         nfc = text.Truncator('o\xfco\xfco\xfco\xfc')
@@ -94,53 +91,55 @@ class TestUtilsText(SimpleTestCase):
         self.assertEqual(text.Truncator(lazystr('The quick brown fox')).chars(12), 'The quick...')
 
     def test_truncate_words(self):
-        truncator = text.Truncator('The quick brown fox jumped over the lazy '
-            'dog.')
-        self.assertEqual('The quick brown fox jumped over the lazy dog.',
-            truncator.words(10))
+        truncator = text.Truncator('The quick brown fox jumped over the lazy dog.')
+        self.assertEqual('The quick brown fox jumped over the lazy dog.', truncator.words(10))
         self.assertEqual('The quick brown fox...', truncator.words(4))
-        self.assertEqual('The quick brown fox[snip]',
-            truncator.words(4, '[snip]'))
+        self.assertEqual('The quick brown fox[snip]', truncator.words(4, '[snip]'))
         # Ensure that lazy strings are handled correctly
         truncator = text.Truncator(lazystr('The quick brown fox jumped over the lazy dog.'))
         self.assertEqual('The quick brown fox...', truncator.words(4))
 
     def test_truncate_html_words(self):
-        truncator = text.Truncator('<p id="par"><strong><em>The quick brown fox'
-            ' jumped over the lazy dog.</em></strong></p>')
-        self.assertEqual('<p id="par"><strong><em>The quick brown fox jumped over'
-            ' the lazy dog.</em></strong></p>', truncator.words(10, html=True))
-        self.assertEqual('<p id="par"><strong><em>The quick brown fox...</em>'
-            '</strong></p>', truncator.words(4, html=True))
-        self.assertEqual('<p id="par"><strong><em>The quick brown fox....</em>'
-            '</strong></p>', truncator.words(4, '....', html=True))
-        self.assertEqual('<p id="par"><strong><em>The quick brown fox</em>'
-            '</strong></p>', truncator.words(4, '', html=True))
+        truncator = text.Truncator(
+            '<p id="par"><strong><em>The quick brown fox jumped over the lazy dog.</em></strong></p>'
+        )
+        self.assertEqual(
+            '<p id="par"><strong><em>The quick brown fox jumped over the lazy dog.</em></strong></p>',
+            truncator.words(10, html=True)
+        )
+        self.assertEqual(
+            '<p id="par"><strong><em>The quick brown fox...</em></strong></p>',
+            truncator.words(4, html=True)
+        )
+        self.assertEqual(
+            '<p id="par"><strong><em>The quick brown fox....</em></strong></p>',
+            truncator.words(4, '....', html=True)
+        )
+        self.assertEqual(
+            '<p id="par"><strong><em>The quick brown fox</em></strong></p>',
+            truncator.words(4, '', html=True)
+        )
 
         # Test with new line inside tag
-        truncator = text.Truncator('<p>The quick <a href="xyz.html"\n'
-            'id="mylink">brown fox</a> jumped over the lazy dog.</p>')
-        self.assertEqual('<p>The quick <a href="xyz.html"\n'
-            'id="mylink">brown...</a></p>', truncator.words(3, '...', html=True))
+        truncator = text.Truncator(
+            '<p>The quick <a href="xyz.html"\n id="mylink">brown fox</a> jumped over the lazy dog.</p>'
+        )
+        self.assertEqual(
+            '<p>The quick <a href="xyz.html"\n id="mylink">brown...</a></p>',
+            truncator.words(3, '...', html=True)
+        )
 
         # Test self-closing tags
-        truncator = text.Truncator('<br/>The <hr />quick brown fox jumped over'
-            ' the lazy dog.')
-        self.assertEqual('<br/>The <hr />quick brown...',
-            truncator.words(3, '...', html=True))
-        truncator = text.Truncator('<br>The <hr/>quick <em>brown fox</em> '
-            'jumped over the lazy dog.')
-        self.assertEqual('<br>The <hr/>quick <em>brown...</em>',
-            truncator.words(3, '...', html=True))
+        truncator = text.Truncator('<br/>The <hr />quick brown fox jumped over the lazy dog.')
+        self.assertEqual('<br/>The <hr />quick brown...', truncator.words(3, '...', html=True))
+        truncator = text.Truncator('<br>The <hr/>quick <em>brown fox</em> jumped over the lazy dog.')
+        self.assertEqual('<br>The <hr/>quick <em>brown...</em>', truncator.words(3, '...', html=True))
 
         # Test html entities
-        truncator = text.Truncator('<i>Buenos d&iacute;as!'
-            ' &#x00bf;C&oacute;mo est&aacute;?</i>')
-        self.assertEqual('<i>Buenos d&iacute;as! &#x00bf;C&oacute;mo...</i>',
-            truncator.words(3, '...', html=True))
+        truncator = text.Truncator('<i>Buenos d&iacute;as! &#x00bf;C&oacute;mo est&aacute;?</i>')
+        self.assertEqual('<i>Buenos d&iacute;as! &#x00bf;C&oacute;mo...</i>', truncator.words(3, '...', html=True))
         truncator = text.Truncator('<p>I &lt;3 python, what about you?</p>')
-        self.assertEqual('<p>I &lt;3 python...</p>',
-            truncator.words(3, '...', html=True))
+        self.assertEqual('<p>I &lt;3 python...</p>', truncator.words(3, '...', html=True))
 
     def test_wrap(self):
         digits = '1234 67 9'
@@ -148,21 +147,16 @@ class TestUtilsText(SimpleTestCase):
         self.assertEqual(text.wrap(digits, 9), '1234 67 9')
         self.assertEqual(text.wrap(digits, 8), '1234 67\n9')
 
-        self.assertEqual(text.wrap('short\na long line', 7),
-                         'short\na long\nline')
-
-        self.assertEqual(text.wrap('do-not-break-long-words please? ok', 8),
-                         'do-not-break-long-words\nplease?\nok')
+        self.assertEqual(text.wrap('short\na long line', 7), 'short\na long\nline')
+        self.assertEqual(text.wrap('do-not-break-long-words please? ok', 8), 'do-not-break-long-words\nplease?\nok')
 
         long_word = 'l%sng' % ('o' * 20)
         self.assertEqual(text.wrap(long_word, 20), long_word)
-        self.assertEqual(text.wrap('a %s word' % long_word, 10),
-                         'a\n%s\nword' % long_word)
+        self.assertEqual(text.wrap('a %s word' % long_word, 10), 'a\n%s\nword' % long_word)
         self.assertEqual(text.wrap(lazystr(digits), 100), '1234 67 9')
 
     def test_normalize_newlines(self):
-        self.assertEqual(text.normalize_newlines("abc\ndef\rghi\r\n"),
-                         "abc\ndef\nghi\n")
+        self.assertEqual(text.normalize_newlines("abc\ndef\rghi\r\n"), "abc\ndef\nghi\n")
         self.assertEqual(text.normalize_newlines("\n\r\r\n\r"), "\n\n\n\n")
         self.assertEqual(text.normalize_newlines("abcdefghi"), "abcdefghi")
         self.assertEqual(text.normalize_newlines(""), "")
diff --git a/tests/utils_tests/test_timesince.py b/tests/utils_tests/test_timesince.py
index ea1064f902..a410032acf 100644
--- a/tests/utils_tests/test_timesince.py
+++ b/tests/utils_tests/test_timesince.py
@@ -28,71 +28,53 @@ class TimesinceTests(unittest.TestCase):
 
     def test_ignore_microseconds_and_seconds(self):
         """ Microseconds and seconds are ignored. """
-        self.assertEqual(timesince(self.t, self.t + self.onemicrosecond),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t, self.t + self.onesecond),
-            '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t + self.onemicrosecond), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t + self.onesecond), '0\xa0minutes')
 
     def test_other_units(self):
         """ Test other units. """
-        self.assertEqual(timesince(self.t, self.t + self.oneminute),
-            '1\xa0minute')
+        self.assertEqual(timesince(self.t, self.t + self.oneminute), '1\xa0minute')
         self.assertEqual(timesince(self.t, self.t + self.onehour), '1\xa0hour')
         self.assertEqual(timesince(self.t, self.t + self.oneday), '1\xa0day')
         self.assertEqual(timesince(self.t, self.t + self.oneweek), '1\xa0week')
-        self.assertEqual(timesince(self.t, self.t + self.onemonth),
-            '1\xa0month')
+        self.assertEqual(timesince(self.t, self.t + self.onemonth), '1\xa0month')
         self.assertEqual(timesince(self.t, self.t + self.oneyear), '1\xa0year')
 
     def test_multiple_units(self):
         """ Test multiple units. """
-        self.assertEqual(timesince(self.t,
-            self.t + 2 * self.oneday + 6 * self.onehour), '2\xa0days, 6\xa0hours')
-        self.assertEqual(timesince(self.t,
-            self.t + 2 * self.oneweek + 2 * self.oneday), '2\xa0weeks, 2\xa0days')
+        self.assertEqual(timesince(self.t, self.t + 2 * self.oneday + 6 * self.onehour), '2\xa0days, 6\xa0hours')
+        self.assertEqual(timesince(self.t, self.t + 2 * self.oneweek + 2 * self.oneday), '2\xa0weeks, 2\xa0days')
 
     def test_display_first_unit(self):
         """
         If the two differing units aren't adjacent, only the first unit is
         displayed.
         """
-        self.assertEqual(timesince(self.t,
-            self.t + 2 * self.oneweek + 3 * self.onehour + 4 * self.oneminute),
-            '2\xa0weeks')
-
-        self.assertEqual(timesince(self.t,
-            self.t + 4 * self.oneday + 5 * self.oneminute), '4\xa0days')
+        self.assertEqual(
+            timesince(self.t, self.t + 2 * self.oneweek + 3 * self.onehour + 4 * self.oneminute),
+            '2\xa0weeks'
+        )
+        self.assertEqual(timesince(self.t, self.t + 4 * self.oneday + 5 * self.oneminute), '4\xa0days')
 
     def test_display_second_before_first(self):
         """
         When the second date occurs before the first, we should always
         get 0 minutes.
         """
-        self.assertEqual(timesince(self.t, self.t - self.onemicrosecond),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t, self.t - self.onesecond),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t, self.t - self.oneminute),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t, self.t - self.onehour),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t, self.t - self.oneday),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t, self.t - self.oneweek),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t, self.t - self.onemonth),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t, self.t - self.oneyear),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t,
-            self.t - 2 * self.oneday - 6 * self.onehour), '0\xa0minutes')
-        self.assertEqual(timesince(self.t,
-            self.t - 2 * self.oneweek - 2 * self.oneday), '0\xa0minutes')
-        self.assertEqual(timesince(self.t,
-            self.t - 2 * self.oneweek - 3 * self.onehour - 4 * self.oneminute),
-            '0\xa0minutes')
-        self.assertEqual(timesince(self.t,
-            self.t - 4 * self.oneday - 5 * self.oneminute), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - self.onemicrosecond), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - self.onesecond), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - self.oneminute), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - self.onehour), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - self.oneday), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - self.oneweek), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - self.onemonth), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - self.oneyear), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - 2 * self.oneday - 6 * self.onehour), '0\xa0minutes')
+        self.assertEqual(timesince(self.t, self.t - 2 * self.oneweek - 2 * self.oneday), '0\xa0minutes')
+        self.assertEqual(
+            timesince(self.t, self.t - 2 * self.oneweek - 3 * self.onehour - 4 * self.oneminute), '0\xa0minutes'
+        )
+        self.assertEqual(timesince(self.t, self.t - 4 * self.oneday - 5 * self.oneminute), '0\xa0minutes')
 
     @requires_tz_support
     def test_different_timezones(self):