mirror of
https://github.com/django/django.git
synced 2025-08-03 18:38:50 +00:00
Fixed E128 flake8 warnings in tests/.
This commit is contained in:
Tim Graham
parent
df8d8d4292
commit
92053acbb9
148 changed files with 2073 additions and 2248 deletions
|
|
@ -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):
|
||||
|
|
|
|||
|
|
@ -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 = [
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
|
|
|
|||
|
|
@ -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ías!'
|
||||
' ¿Cómo está?</i>')
|
||||
self.assertEqual('<i>Buenos días! ¿Cómo...</i>',
|
||||
truncator.words(3, '...', html=True))
|
||||
truncator = text.Truncator('<i>Buenos días! ¿Cómo está?</i>')
|
||||
self.assertEqual('<i>Buenos días! ¿Cómo...</i>', truncator.words(3, '...', html=True))
|
||||
truncator = text.Truncator('<p>I <3 python, what about you?</p>')
|
||||
self.assertEqual('<p>I <3 python...</p>',
|
||||
truncator.words(3, '...', html=True))
|
||||
self.assertEqual('<p>I <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(""), "")
|
||||
|
|
|
|||
|
|
@ -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):
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue