You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
362 lines
18 KiB
362 lines
18 KiB
# coding: utf-8
|
|
from __future__ import unicode_literals, division, absolute_import, print_function
|
|
|
|
import unittest
|
|
import sys
|
|
import os
|
|
from datetime import date, datetime, time, timedelta
|
|
|
|
from asn1crypto import util
|
|
|
|
from .unittest_data import data_decorator
|
|
from ._unittest_compat import patch
|
|
|
|
patch()
|
|
|
|
if sys.version_info < (3,):
|
|
py2 = True
|
|
byte_cls = str
|
|
num_cls = long # noqa
|
|
else:
|
|
py2 = False
|
|
byte_cls = bytes
|
|
num_cls = int
|
|
|
|
|
|
tests_root = os.path.dirname(__file__)
|
|
fixtures_dir = os.path.join(tests_root, 'fixtures')
|
|
utc = util.timezone.utc
|
|
|
|
|
|
@data_decorator
|
|
class UtilTests(unittest.TestCase):
|
|
|
|
def test_int_to_bytes(self):
|
|
self.assertEqual(util.int_to_bytes(0, False, 0), b'')
|
|
self.assertEqual(util.int_to_bytes(0, False), b'\x00')
|
|
self.assertEqual(util.int_to_bytes(0, False, 3), b'\x00\x00\x00')
|
|
self.assertEqual(util.int_to_bytes(0, True, 0), b'')
|
|
self.assertEqual(util.int_to_bytes(0, True), b'\x00')
|
|
self.assertEqual(util.int_to_bytes(0, True, 3), b'\x00\x00\x00')
|
|
|
|
self.assertEqual(util.int_to_bytes(128, False), b'\x80')
|
|
self.assertEqual(util.int_to_bytes(128, False, 3), b'\x00\x00\x80')
|
|
self.assertEqual(util.int_to_bytes(-128, True), b'\x80')
|
|
self.assertEqual(util.int_to_bytes(-128, True, 3), b'\xff\xff\x80')
|
|
|
|
self.assertEqual(util.int_to_bytes(255, False), b'\xff')
|
|
self.assertEqual(util.int_to_bytes(255, False, 3), b'\x00\x00\xff')
|
|
self.assertEqual(util.int_to_bytes(-1, True), b'\xff')
|
|
self.assertEqual(util.int_to_bytes(-1, True, 3), b'\xff\xff\xff')
|
|
|
|
self.assertEqual(util.int_to_bytes(12345678, False), b'\xbc\x61\x4e')
|
|
self.assertEqual(util.int_to_bytes(12345678, False, 3), b'\xbc\x61\x4e')
|
|
self.assertEqual(util.int_to_bytes(12345678, False, 5), b'\x00\x00\xbc\x61\x4e')
|
|
self.assertEqual(util.int_to_bytes(12345678 - 2 ** 24, True), b'\xbc\x61\x4e')
|
|
self.assertEqual(util.int_to_bytes(12345678 - 2 ** 24, True, 3), b'\xbc\x61\x4e')
|
|
self.assertEqual(util.int_to_bytes(12345678 - 2 ** 24, True, 5), b'\xff\xff\xbc\x61\x4e')
|
|
|
|
with self.assertRaises(OverflowError):
|
|
util.int_to_bytes(123456789, width=3)
|
|
with self.assertRaises(OverflowError):
|
|
util.int_to_bytes(50000, signed=True, width=2)
|
|
|
|
def test_int_from_bytes(self):
|
|
self.assertEqual(util.int_from_bytes(b'', False), 0)
|
|
self.assertEqual(util.int_from_bytes(b'', True), 0)
|
|
self.assertEqual(util.int_from_bytes(b'\x00', False), 0)
|
|
self.assertEqual(util.int_from_bytes(b'\x00', True), 0)
|
|
self.assertEqual(util.int_from_bytes(b'\x80', False), 128)
|
|
self.assertEqual(util.int_from_bytes(b'\x80', True), -128)
|
|
self.assertEqual(util.int_from_bytes(b'\xff', False), 255)
|
|
self.assertEqual(util.int_from_bytes(b'\xff', True), -1)
|
|
self.assertEqual(util.int_from_bytes(b'\xbc\x61\x4e', False), 12345678)
|
|
self.assertEqual(util.int_from_bytes(b'\xbc\x61\x4e', True), 12345678 - 2 ** 24)
|
|
|
|
def test_int_fromto_bytes(self):
|
|
for i in range(-300, 301):
|
|
self.assertEqual(i, util.int_from_bytes(util.int_to_bytes(i, True), True))
|
|
for i in range(0, 301):
|
|
self.assertEqual(i, util.int_from_bytes(util.int_to_bytes(i, False), False))
|
|
|
|
def test_timezone(self):
|
|
delta_plus_5_42 = timedelta(hours=5, minutes=42)
|
|
delta_minus_5_42 = -delta_plus_5_42
|
|
|
|
# limited to +24h
|
|
with self.assertRaises(ValueError):
|
|
util.timezone(delta_plus_5_42 * 5)
|
|
|
|
# limited to -24h
|
|
with self.assertRaises(ValueError):
|
|
util.timezone(delta_minus_5_42 * 5)
|
|
|
|
# py2 implementation supports no sub-minutes time zones
|
|
if py2:
|
|
with self.assertRaises(ValueError):
|
|
util.timezone(timedelta(hours=5, minutes=42, seconds=13))
|
|
|
|
with self.assertRaises(ValueError):
|
|
util.timezone(timedelta(hours=5, minutes=42, microseconds=13))
|
|
|
|
# test __eq__
|
|
tz0 = util.timezone(delta_plus_5_42)
|
|
tz1 = util.timezone(delta_minus_5_42)
|
|
self.assertEqual(tz0, tz0)
|
|
self.assertEqual(tz1, tz1)
|
|
self.assertNotEqual(tz0, tz1)
|
|
self.assertFalse(tz0 == "not equal to a str")
|
|
|
|
# test tzname
|
|
self.assertEqual('5_42', util.timezone(delta_plus_5_42, '5_42').tzname(None))
|
|
self.assertEqual('UTC+05:42', util.timezone(delta_plus_5_42).tzname(None))
|
|
self.assertEqual('UTC-05:42', util.timezone(delta_minus_5_42).tzname(None))
|
|
if py2 or sys.version_info >= (3, 6):
|
|
# bpo22241
|
|
self.assertEqual('UTC', util.timezone(timedelta(0)).tzname(None))
|
|
|
|
# test utcoffset
|
|
self.assertEqual(delta_minus_5_42, util.timezone(delta_minus_5_42).utcoffset(None))
|
|
|
|
# test dst
|
|
self.assertTrue(util.timezone(delta_minus_5_42).dst(None) in set((timedelta(0), None)))
|
|
|
|
# test create_timezone
|
|
self.assertTrue(util.create_timezone(delta_plus_5_42) is util.create_timezone(timedelta(hours=5, minutes=42)))
|
|
self.assertFalse(util.create_timezone(delta_plus_5_42) is util.create_timezone(delta_minus_5_42))
|
|
|
|
def test_utc_with_dst(self):
|
|
self.assertEqual('UTC', util.utc_with_dst.tzname(None))
|
|
|
|
def test_extended_date_strftime(self):
|
|
self.assertEqual('0000-01-01', util.extended_date(0, 1, 1).strftime('%Y-%m-%d'))
|
|
self.assertEqual('Sat Saturday Jan January', util.extended_date(0, 1, 1).strftime('%a %A %b %B'))
|
|
self.assertEqual('Tue Tuesday Feb February 29', util.extended_date(0, 2, 29).strftime('%a %A %b %B %d'))
|
|
if sys.platform == 'win32' and sys.version_info < (3, 5):
|
|
self.assertEqual('01/01/00 00:00:00', util.extended_date(0, 1, 1).strftime('%c'))
|
|
else:
|
|
self.assertEqual('Sat Jan 1 00:00:00 0000', util.extended_date(0, 1, 1).strftime('%c'))
|
|
self.assertEqual('01/01/00', util.extended_date(0, 1, 1).strftime('%x'))
|
|
|
|
def test_extended_datetime_init(self):
|
|
with self.assertRaises(ValueError):
|
|
util.extended_datetime(2000, 11, 27)
|
|
|
|
def test_extended_date_init(self):
|
|
with self.assertRaises(ValueError):
|
|
util.extended_date(2000, 11, 27)
|
|
|
|
def test_extended_datetime_properties(self):
|
|
zone = util.create_timezone(timedelta(hours=12, minutes=45))
|
|
dt = util.extended_datetime(0, 11, 27, 5, 44, 31, 14889, zone)
|
|
self.assertEqual(dt.year, 0)
|
|
self.assertEqual(dt.month, 11)
|
|
self.assertEqual(dt.day, 27)
|
|
self.assertEqual(dt.hour, 5)
|
|
self.assertEqual(dt.minute, 44)
|
|
self.assertEqual(dt.second, 31)
|
|
self.assertEqual(dt.microsecond, 14889)
|
|
self.assertEqual(dt.tzinfo, zone)
|
|
|
|
def test_extended_date_properties(self):
|
|
ext_date = util.extended_date(0, 11, 27)
|
|
self.assertEqual(ext_date.year, 0)
|
|
self.assertEqual(ext_date.month, 11)
|
|
self.assertEqual(ext_date.day, 27)
|
|
|
|
def test_extended_datetime_isoformat(self):
|
|
self.assertEqual('0000-01-01T00:00:00', util.extended_datetime(0, 1, 1).isoformat())
|
|
self.assertEqual('0000-01-01T00:00:00.001000', util.extended_datetime(0, 1, 1, microsecond=1000).isoformat())
|
|
self.assertEqual('0000-01-01%00:00:00', util.extended_datetime(0, 1, 1).isoformat(sep='%'))
|
|
|
|
def test_extended_date_isoformat(self):
|
|
self.assertEqual('0000-01-01', util.extended_date(0, 1, 1).isoformat())
|
|
self.assertEqual('0000-11-27', util.extended_date(0, 11, 27).isoformat())
|
|
|
|
def test_extended_datetime_strftime(self):
|
|
self.assertEqual('0000-01-01 00:00:00', util.extended_datetime(0, 1, 1).strftime('%Y-%m-%d %H:%M:%S'))
|
|
self.assertEqual('Sat Saturday Jan January', util.extended_datetime(0, 1, 1).strftime('%a %A %b %B'))
|
|
self.assertEqual('Tue Tuesday Feb February 29', util.extended_datetime(0, 2, 29).strftime('%a %A %b %B %d'))
|
|
if sys.platform == 'win32' and sys.version_info < (3, 5):
|
|
self.assertEqual('01/01/00 00:00:00', util.extended_datetime(0, 1, 1).strftime('%c'))
|
|
else:
|
|
self.assertEqual('Sat Jan 1 00:00:00 0000', util.extended_datetime(0, 1, 1).strftime('%c'))
|
|
self.assertEqual('01/01/00', util.extended_datetime(0, 1, 1).strftime('%x'))
|
|
self.assertEqual('%Y', util.extended_datetime(0, 1, 1).strftime('%%Y'))
|
|
|
|
def test_extended_datetime_replace(self):
|
|
zone = util.create_timezone(timedelta(hours=12, minutes=45))
|
|
ext_dt = util.extended_datetime(0, 1, 1, 23, tzinfo=zone)
|
|
self.assertEqual(ext_dt.replace(year=2040, minute=59), datetime(2040, 1, 1, 23, 59, tzinfo=zone))
|
|
self.assertEqual(ext_dt.replace(minute=59), util.extended_datetime(0, 1, 1, 23, 59, tzinfo=zone))
|
|
|
|
def test_extended_date_replace(self):
|
|
ext_date = util.extended_date(0, 2, 27)
|
|
self.assertEqual(ext_date.replace(year=2040), date(2040, 2, 27))
|
|
self.assertEqual(ext_date.replace(day=29), util.extended_date(0, 2, 29))
|
|
with self.assertRaises(ValueError):
|
|
ext_date.replace(day=30)
|
|
|
|
def test_extended_datetime_encodings(self):
|
|
zone = util.create_timezone(timedelta(hours=12, minutes=45))
|
|
|
|
# test with microseconds
|
|
ext_dt = util.extended_datetime(0, 2, 29, 9, 17, 45, 14889, zone)
|
|
self.assertEqual(str(ext_dt), '0000-02-29 09:17:45.014889+12:45')
|
|
if py2:
|
|
self.assertEqual(unicode(ext_dt), '0000-02-29 09:17:45.014889+12:45') # noqa: F821
|
|
|
|
# test without microseconds
|
|
ext_dt = util.extended_datetime(0, 2, 29, 9, 17, 45, 0, zone)
|
|
self.assertEqual(str(ext_dt), '0000-02-29 09:17:45+12:45')
|
|
if py2:
|
|
self.assertEqual(unicode(ext_dt), '0000-02-29 09:17:45+12:45') # noqa: F821
|
|
|
|
def test_extended_date_encodings(self):
|
|
ext_date = util.extended_date(0, 2, 29)
|
|
self.assertEqual(str(ext_date), '0000-02-29')
|
|
if py2:
|
|
self.assertEqual(unicode(ext_date), '0000-02-29') # noqa: F821
|
|
|
|
def test_extended_datetime_timestamp(self):
|
|
if sys.version_info >= (3, 3):
|
|
zone = util.create_timezone(timedelta(hours=12, minutes=45))
|
|
ext_dt = util.extended_datetime(0, 12, 31, 23, 0, 0, 14889, zone)
|
|
dt = datetime(1, 1, 1, 0, 0, 0, 14889, zone)
|
|
self.assertTrue(abs(dt.timestamp() - ext_dt.timestamp() - 3600.0) < 0.0000001)
|
|
|
|
def test_extended_date_compare(self):
|
|
self.assertTrue(util.extended_date(0, 1, 1) < date(1, 1, 1))
|
|
self.assertTrue(util.extended_date(0, 1, 1) <= date(1, 1, 1))
|
|
self.assertTrue(util.extended_date(0, 1, 1) != date(1, 1, 1))
|
|
self.assertFalse(util.extended_date(0, 1, 1) == date(1, 1, 1))
|
|
self.assertFalse(util.extended_date(0, 1, 1) >= date(1, 1, 1))
|
|
self.assertFalse(util.extended_date(0, 1, 1) > date(1, 1, 1))
|
|
|
|
self.assertFalse(util.extended_date(0, 1, 1) < util.extended_date(0, 1, 1))
|
|
self.assertTrue(util.extended_date(0, 1, 1) <= util.extended_date(0, 1, 1))
|
|
self.assertFalse(util.extended_date(0, 1, 1) != util.extended_date(0, 1, 1))
|
|
self.assertTrue(util.extended_date(0, 1, 1) == util.extended_date(0, 1, 1))
|
|
self.assertTrue(util.extended_date(0, 1, 1) >= util.extended_date(0, 1, 1))
|
|
self.assertFalse(util.extended_date(0, 1, 1) > util.extended_date(0, 1, 1))
|
|
|
|
self.assertTrue(util.extended_date(0, 1, 1) < util.extended_date(0, 1, 2))
|
|
self.assertTrue(util.extended_date(0, 1, 1) <= util.extended_date(0, 1, 2))
|
|
self.assertTrue(util.extended_date(0, 1, 1) != util.extended_date(0, 1, 2))
|
|
self.assertFalse(util.extended_date(0, 1, 1) == util.extended_date(0, 1, 2))
|
|
self.assertFalse(util.extended_date(0, 1, 1) >= util.extended_date(0, 1, 2))
|
|
self.assertFalse(util.extended_date(0, 1, 1) > util.extended_date(0, 1, 2))
|
|
|
|
self.assertFalse(util.extended_date(0, 1, 3) < util.extended_date(0, 1, 2))
|
|
self.assertFalse(util.extended_date(0, 1, 3) <= util.extended_date(0, 1, 2))
|
|
self.assertTrue(util.extended_date(0, 1, 3) != util.extended_date(0, 1, 2))
|
|
self.assertFalse(util.extended_date(0, 1, 3) == util.extended_date(0, 1, 2))
|
|
self.assertTrue(util.extended_date(0, 1, 3) >= util.extended_date(0, 1, 2))
|
|
self.assertTrue(util.extended_date(0, 1, 3) > util.extended_date(0, 1, 2))
|
|
|
|
with self.assertRaises(TypeError):
|
|
util.extended_date(0, 1, 1) < "0000-01-02"
|
|
|
|
def test_extended_datetime_compare(self):
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) < datetime(1, 1, 1))
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) <= datetime(1, 1, 1))
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) != datetime(1, 1, 1))
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) == datetime(1, 1, 1))
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) >= datetime(1, 1, 1))
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) > datetime(1, 1, 1))
|
|
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) < util.extended_datetime(0, 1, 1))
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) <= util.extended_datetime(0, 1, 1))
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) != util.extended_datetime(0, 1, 1))
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) == util.extended_datetime(0, 1, 1))
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) >= util.extended_datetime(0, 1, 1))
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) > util.extended_datetime(0, 1, 1))
|
|
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) < util.extended_datetime(0, 1, 2))
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) <= util.extended_datetime(0, 1, 2))
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) != util.extended_datetime(0, 1, 2))
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) == util.extended_datetime(0, 1, 2))
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) >= util.extended_datetime(0, 1, 2))
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) > util.extended_datetime(0, 1, 2))
|
|
|
|
self.assertFalse(util.extended_datetime(0, 1, 3) < util.extended_datetime(0, 1, 2))
|
|
self.assertFalse(util.extended_datetime(0, 1, 3) <= util.extended_datetime(0, 1, 2))
|
|
self.assertTrue(util.extended_datetime(0, 1, 3) != util.extended_datetime(0, 1, 2))
|
|
self.assertFalse(util.extended_datetime(0, 1, 3) == util.extended_datetime(0, 1, 2))
|
|
self.assertTrue(util.extended_datetime(0, 1, 3) >= util.extended_datetime(0, 1, 2))
|
|
self.assertTrue(util.extended_datetime(0, 1, 3) > util.extended_datetime(0, 1, 2))
|
|
self.assertTrue(
|
|
util.extended_datetime(0, 12, 31, 21, 4, 5, 6, util.create_timezone(timedelta(hours=-8)))
|
|
== datetime(1, 1, 1, 5, 4, 5, 6, utc)
|
|
)
|
|
self.assertTrue(
|
|
util.extended_datetime(0, 12, 31, 21, 4, 5, 6, util.create_timezone(timedelta(hours=-8)))
|
|
== datetime(1, 1, 1, 5, 7, 5, 6, util.create_timezone(timedelta(hours=0, minutes=3)))
|
|
)
|
|
self.assertFalse(
|
|
util.extended_datetime(0, 12, 31, 21, 4, 5, 6, util.create_timezone(timedelta(hours=-7)))
|
|
== datetime(1, 1, 1, 5, 4, 5, 6, utc)
|
|
)
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) == util.extended_datetime(0, 1, 1, tzinfo=utc))
|
|
self.assertFalse(util.extended_datetime(0, 1, 1) == "0000-01-01")
|
|
|
|
with self.assertRaises(TypeError):
|
|
util.extended_datetime(0, 1, 1) < "0000-01-02"
|
|
|
|
def test_extended_datetime_arithmetic(self):
|
|
zone = util.create_timezone(timedelta(hours=12, minutes=45))
|
|
ext_dt = util.extended_datetime(0, 12, 31, 9, 17, 45, 14889, zone)
|
|
self.assertEqual(ext_dt + timedelta(hours=20), datetime(1, 1, 1, 5, 17, 45, 14889, zone))
|
|
self.assertEqual(ext_dt - timedelta(hours=20), util.extended_datetime(0, 12, 30, 13, 17, 45, 14889, zone))
|
|
self.assertEqual(ext_dt - ext_dt, timedelta(0))
|
|
|
|
zone2 = util.create_timezone(timedelta(hours=-8, minutes=-31))
|
|
ext_dt2 = util.extended_datetime(0, 11, 14, 13, 44, 20, 876543, zone2)
|
|
expected_diff = timedelta(days=47, hours=-4, minutes=-27, seconds=25, microseconds=-861654)
|
|
expected_diff -= timedelta(hours=20, minutes=76)
|
|
self.assertEqual(ext_dt - ext_dt2, expected_diff)
|
|
|
|
dt = datetime(400, 12, 31, 9, 17, 45, 14889, zone)
|
|
self.assertEqual(dt - ext_dt, timedelta(days=util.extended_datetime.DAYS_IN_400_YEARS))
|
|
self.assertEqual(ext_dt - dt, -timedelta(days=util.extended_datetime.DAYS_IN_400_YEARS))
|
|
|
|
with self.assertRaises(TypeError):
|
|
ext_dt - "test"
|
|
|
|
def test_extended_datetime_compare_tzinfo(self):
|
|
with self.assertRaises(TypeError):
|
|
self.assertTrue(util.extended_datetime(0, 1, 1, tzinfo=utc) < datetime(1, 1, 1))
|
|
with self.assertRaises(TypeError):
|
|
self.assertTrue(util.extended_datetime(0, 1, 1) < datetime(1, 1, 1, tzinfo=utc))
|
|
|
|
def test_extended_datetime_date_time(self):
|
|
self.assertEqual(util.extended_date(0, 1, 1), util.extended_datetime(0, 1, 1).date())
|
|
self.assertEqual(util.extended_date(0, 2, 29), util.extended_datetime(0, 2, 29).date())
|
|
self.assertEqual(time(0, 0, 0), util.extended_datetime(0, 1, 1).time())
|
|
|
|
def test_iri_to_uri(self):
|
|
self.assertEqual(
|
|
b'ldap://ldap.e-szigno.hu/CN=Microsec%20e-Szigno%20Root%20CA,OU=e-Szigno%20CA,'
|
|
b'O=Microsec%20Ltd.,L=Budapest,C=HU?certificateRevocationList;binary',
|
|
util.iri_to_uri(
|
|
'ldap://ldap.e-szigno.hu/CN=Microsec e-Szigno Root CA,'
|
|
'OU=e-Szigno CA,O=Microsec Ltd.,L=Budapest,C=HU?certificateRevocationList;binary'
|
|
)
|
|
)
|
|
self.assertEqual(
|
|
b'ldap://directory.d-trust.net/CN=D-TRUST%20Root%20Class%203%20CA%202%202009,'
|
|
b'O=D-Trust%20GmbH,C=DE?certificaterevocationlist',
|
|
util.iri_to_uri(
|
|
'ldap://directory.d-trust.net/CN=D-TRUST Root Class 3 CA 2 2009,'
|
|
'O=D-Trust GmbH,C=DE?certificaterevocationlist'
|
|
)
|
|
)
|
|
self.assertEqual(
|
|
b'ldap://directory.d-trust.net/CN=D-TRUST%20Root%20Class%203%20CA%202%20EV%202009,'
|
|
b'O=D-Trust%20GmbH,C=DE?certificaterevocationlist',
|
|
util.iri_to_uri(
|
|
'ldap://directory.d-trust.net/CN=D-TRUST Root Class 3 CA 2 EV 2009,'
|
|
'O=D-Trust GmbH,C=DE?certificaterevocationlist'
|
|
)
|
|
)
|