diff options
Diffstat (limited to 'parts/django/tests/regressiontests/utils')
23 files changed, 1192 insertions, 0 deletions
diff --git a/parts/django/tests/regressiontests/utils/__init__.py b/parts/django/tests/regressiontests/utils/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/__init__.py diff --git a/parts/django/tests/regressiontests/utils/checksums.py b/parts/django/tests/regressiontests/utils/checksums.py new file mode 100644 index 0000000..cee6dca --- /dev/null +++ b/parts/django/tests/regressiontests/utils/checksums.py @@ -0,0 +1,29 @@ +import unittest + +from django.utils import checksums + +class TestUtilsChecksums(unittest.TestCase): + + def check_output(self, function, value, output=None): + """ + Check that function(value) equals output. If output is None, + check that function(value) equals value. + """ + if output is None: + output = value + self.assertEqual(function(value), output) + + def test_luhn(self): + f = checksums.luhn + items = ( + (4111111111111111, True), ('4111111111111111', True), + (4222222222222, True), (378734493671000, True), + (5424000000000015, True), (5555555555554444, True), + (1008, True), ('0000001008', True), ('000000001008', True), + (4012888888881881, True), (1234567890123456789012345678909, True), + (4111111111211111, False), (42222222222224, False), + (100, False), ('100', False), ('0000100', False), + ('abc', False), (None, False), (object(), False), + ) + for value, output in items: + self.check_output(f, value, output) diff --git a/parts/django/tests/regressiontests/utils/datastructures.py b/parts/django/tests/regressiontests/utils/datastructures.py new file mode 100644 index 0000000..a41281c --- /dev/null +++ b/parts/django/tests/regressiontests/utils/datastructures.py @@ -0,0 +1,256 @@ +""" +Tests for stuff in django.utils.datastructures. +""" +import pickle +import unittest + +from django.utils.datastructures import * + + +class DatastructuresTestCase(unittest.TestCase): + def assertRaisesErrorWithMessage(self, error, message, callable, + *args, **kwargs): + self.assertRaises(error, callable, *args, **kwargs) + try: + callable(*args, **kwargs) + except error, e: + self.assertEqual(message, str(e)) + + +class SortedDictTests(DatastructuresTestCase): + def setUp(self): + self.d1 = SortedDict() + self.d1[7] = 'seven' + self.d1[1] = 'one' + self.d1[9] = 'nine' + + self.d2 = SortedDict() + self.d2[1] = 'one' + self.d2[9] = 'nine' + self.d2[0] = 'nil' + self.d2[7] = 'seven' + + def test_basic_methods(self): + self.assertEquals(self.d1.keys(), [7, 1, 9]) + self.assertEquals(self.d1.values(), ['seven', 'one', 'nine']) + self.assertEquals(self.d1.items(), [(7, 'seven'), (1, 'one'), (9, 'nine')]) + + def test_overwrite_ordering(self): + """ Overwriting an item keeps it's place. """ + self.d1[1] = 'ONE' + self.assertEquals(self.d1.values(), ['seven', 'ONE', 'nine']) + + def test_append_items(self): + """ New items go to the end. """ + self.d1[0] = 'nil' + self.assertEquals(self.d1.keys(), [7, 1, 9, 0]) + + def test_delete_and_insert(self): + """ + Deleting an item, then inserting the same key again will place it + at the end. + """ + del self.d2[7] + self.assertEquals(self.d2.keys(), [1, 9, 0]) + self.d2[7] = 'lucky number 7' + self.assertEquals(self.d2.keys(), [1, 9, 0, 7]) + + def test_change_keys(self): + """ + Changing the keys won't do anything, it's only a copy of the + keys dict. + """ + k = self.d2.keys() + k.remove(9) + self.assertEquals(self.d2.keys(), [1, 9, 0, 7]) + + def test_init_keys(self): + """ + Initialising a SortedDict with two keys will just take the first one. + + A real dict will actually take the second value so we will too, but + we'll keep the ordering from the first key found. + """ + tuples = ((2, 'two'), (1, 'one'), (2, 'second-two')) + d = SortedDict(tuples) + + self.assertEquals(d.keys(), [2, 1]) + + real_dict = dict(tuples) + self.assertEquals(sorted(real_dict.values()), ['one', 'second-two']) + + # Here the order of SortedDict values *is* what we are testing + self.assertEquals(d.values(), ['second-two', 'one']) + + def test_overwrite(self): + self.d1[1] = 'not one' + self.assertEqual(self.d1[1], 'not one') + self.assertEqual(self.d1.keys(), self.d1.copy().keys()) + + def test_append(self): + self.d1[13] = 'thirteen' + self.assertEquals( + repr(self.d1), + "{7: 'seven', 1: 'one', 9: 'nine', 13: 'thirteen'}" + ) + + def test_pop(self): + self.assertEquals(self.d1.pop(1, 'missing'), 'one') + self.assertEquals(self.d1.pop(1, 'missing'), 'missing') + + # We don't know which item will be popped in popitem(), so we'll + # just check that the number of keys has decreased. + l = len(self.d1) + self.d1.popitem() + self.assertEquals(l - len(self.d1), 1) + + def test_dict_equality(self): + d = SortedDict((i, i) for i in xrange(3)) + self.assertEquals(d, {0: 0, 1: 1, 2: 2}) + + def test_tuple_init(self): + d = SortedDict(((1, "one"), (0, "zero"), (2, "two"))) + self.assertEquals(repr(d), "{1: 'one', 0: 'zero', 2: 'two'}") + + def test_pickle(self): + self.assertEquals( + pickle.loads(pickle.dumps(self.d1, 2)), + {7: 'seven', 1: 'one', 9: 'nine'} + ) + + def test_clear(self): + self.d1.clear() + self.assertEquals(self.d1, {}) + self.assertEquals(self.d1.keyOrder, []) + +class MergeDictTests(DatastructuresTestCase): + + def test_simple_mergedict(self): + d1 = {'chris':'cool', 'camri':'cute', 'cotton':'adorable', + 'tulip':'snuggable', 'twoofme':'firstone'} + + d2 = {'chris2':'cool2', 'camri2':'cute2', 'cotton2':'adorable2', + 'tulip2':'snuggable2'} + + d3 = {'chris3':'cool3', 'camri3':'cute3', 'cotton3':'adorable3', + 'tulip3':'snuggable3'} + + d4 = {'twoofme': 'secondone'} + + md = MergeDict(d1, d2, d3) + + self.assertEquals(md['chris'], 'cool') + self.assertEquals(md['camri'], 'cute') + self.assertEquals(md['twoofme'], 'firstone') + + md2 = md.copy() + self.assertEquals(md2['chris'], 'cool') + + def test_mergedict_merges_multivaluedict(self): + """ MergeDict can merge MultiValueDicts """ + + multi1 = MultiValueDict({'key1': ['value1'], + 'key2': ['value2', 'value3']}) + + multi2 = MultiValueDict({'key2': ['value4'], + 'key4': ['value5', 'value6']}) + + mm = MergeDict(multi1, multi2) + + # Although 'key2' appears in both dictionaries, + # only the first value is used. + self.assertEquals(mm.getlist('key2'), ['value2', 'value3']) + self.assertEquals(mm.getlist('key4'), ['value5', 'value6']) + self.assertEquals(mm.getlist('undefined'), []) + + self.assertEquals(sorted(mm.keys()), ['key1', 'key2', 'key4']) + self.assertEquals(len(mm.values()), 3) + + self.assertTrue('value1' in mm.values()) + + self.assertEquals(sorted(mm.items(), key=lambda k: k[0]), + [('key1', 'value1'), ('key2', 'value3'), + ('key4', 'value6')]) + + self.assertEquals([(k,mm.getlist(k)) for k in sorted(mm)], + [('key1', ['value1']), + ('key2', ['value2', 'value3']), + ('key4', ['value5', 'value6'])]) + +class MultiValueDictTests(DatastructuresTestCase): + + def test_multivaluedict(self): + d = MultiValueDict({'name': ['Adrian', 'Simon'], + 'position': ['Developer']}) + + self.assertEquals(d['name'], 'Simon') + self.assertEquals(d.get('name'), 'Simon') + self.assertEquals(d.getlist('name'), ['Adrian', 'Simon']) + self.assertEquals(list(d.iteritems()), + [('position', 'Developer'), ('name', 'Simon')]) + + self.assertEquals(list(d.iterlists()), + [('position', ['Developer']), + ('name', ['Adrian', 'Simon'])]) + + # MultiValueDictKeyError: "Key 'lastname' not found in + # <MultiValueDict: {'position': ['Developer'], + # 'name': ['Adrian', 'Simon']}>" + self.assertRaisesErrorWithMessage(MultiValueDictKeyError, + '"Key \'lastname\' not found in <MultiValueDict: {\'position\':'\ + ' [\'Developer\'], \'name\': [\'Adrian\', \'Simon\']}>"', + d.__getitem__, 'lastname') + + self.assertEquals(d.get('lastname'), None) + self.assertEquals(d.get('lastname', 'nonexistent'), 'nonexistent') + self.assertEquals(d.getlist('lastname'), []) + + d.setlist('lastname', ['Holovaty', 'Willison']) + self.assertEquals(d.getlist('lastname'), ['Holovaty', 'Willison']) + self.assertEquals(d.values(), ['Developer', 'Simon', 'Willison']) + self.assertEquals(list(d.itervalues()), + ['Developer', 'Simon', 'Willison']) + + +class DotExpandedDictTests(DatastructuresTestCase): + + def test_dotexpandeddict(self): + + d = DotExpandedDict({'person.1.firstname': ['Simon'], + 'person.1.lastname': ['Willison'], + 'person.2.firstname': ['Adrian'], + 'person.2.lastname': ['Holovaty']}) + + self.assertEquals(d['person']['1']['lastname'], ['Willison']) + self.assertEquals(d['person']['2']['lastname'], ['Holovaty']) + self.assertEquals(d['person']['2']['firstname'], ['Adrian']) + + +class ImmutableListTests(DatastructuresTestCase): + + def test_sort(self): + d = ImmutableList(range(10)) + + # AttributeError: ImmutableList object is immutable. + self.assertRaisesErrorWithMessage(AttributeError, + 'ImmutableList object is immutable.', d.sort) + + self.assertEquals(repr(d), '(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)') + + def test_custom_warning(self): + d = ImmutableList(range(10), warning="Object is immutable!") + + self.assertEquals(d[1], 1) + + # AttributeError: Object is immutable! + self.assertRaisesErrorWithMessage(AttributeError, + 'Object is immutable!', d.__setitem__, 1, 'test') + + +class DictWrapperTests(DatastructuresTestCase): + + def test_dictwrapper(self): + f = lambda x: "*%s" % x + d = DictWrapper({'a': 'a'}, f, 'xx_') + self.assertEquals("Normal: %(a)s. Modified: %(xx_a)s" % d, + 'Normal: a. Modified: *a') diff --git a/parts/django/tests/regressiontests/utils/dateformat.py b/parts/django/tests/regressiontests/utils/dateformat.py new file mode 100644 index 0000000..b312c8d --- /dev/null +++ b/parts/django/tests/regressiontests/utils/dateformat.py @@ -0,0 +1,129 @@ +from datetime import datetime, date +import os +import time +import unittest + +from django.utils.dateformat import format +from django.utils import dateformat, translation +from django.utils.tzinfo import FixedOffset, LocalTimezone + +class DateFormatTests(unittest.TestCase): + def setUp(self): + self.old_TZ = os.environ.get('TZ') + os.environ['TZ'] = 'Europe/Copenhagen' + translation.activate('en-us') + + try: + # Check if a timezone has been set + time.tzset() + self.tz_tests = True + except AttributeError: + # No timezone available. Don't run the tests that require a TZ + self.tz_tests = False + + def tearDown(self): + if self.old_TZ is None: + del os.environ['TZ'] + else: + os.environ['TZ'] = self.old_TZ + + # Cleanup - force re-evaluation of TZ environment variable. + if self.tz_tests: + time.tzset() + + def test_date(self): + d = date(2009, 5, 16) + self.assertEquals(date.fromtimestamp(int(format(d, 'U'))), d) + + def test_naive_datetime(self): + dt = datetime(2009, 5, 16, 5, 30, 30) + self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U'))), dt) + + def test_datetime_with_local_tzinfo(self): + ltz = LocalTimezone(datetime.now()) + dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=ltz) + self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt) + self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U'))), dt.replace(tzinfo=None)) + + def test_datetime_with_tzinfo(self): + tz = FixedOffset(-510) + ltz = LocalTimezone(datetime.now()) + dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=tz) + self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), tz), dt) + self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt) + self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U'))), dt.astimezone(ltz).replace(tzinfo=None)) + self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), tz).utctimetuple(), dt.utctimetuple()) + self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), ltz).utctimetuple(), dt.utctimetuple()) + + def test_epoch(self): + utc = FixedOffset(0) + udt = datetime(1970, 1, 1, tzinfo=utc) + self.assertEquals(format(udt, 'U'), u'0') + + def test_empty_format(self): + my_birthday = datetime(1979, 7, 8, 22, 00) + + self.assertEquals(dateformat.format(my_birthday, ''), u'') + + def test_am_pm(self): + my_birthday = datetime(1979, 7, 8, 22, 00) + + self.assertEquals(dateformat.format(my_birthday, 'a'), u'p.m.') + + def test_date_formats(self): + my_birthday = datetime(1979, 7, 8, 22, 00) + timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456) + + self.assertEquals(dateformat.format(my_birthday, 'A'), u'PM') + self.assertEquals(dateformat.format(timestamp, 'c'), u'2008-05-19T11:45:23.123456') + self.assertEquals(dateformat.format(my_birthday, 'd'), u'08') + self.assertEquals(dateformat.format(my_birthday, 'j'), u'8') + self.assertEquals(dateformat.format(my_birthday, 'l'), u'Sunday') + self.assertEquals(dateformat.format(my_birthday, 'L'), u'False') + self.assertEquals(dateformat.format(my_birthday, 'm'), u'07') + self.assertEquals(dateformat.format(my_birthday, 'M'), u'Jul') + self.assertEquals(dateformat.format(my_birthday, 'b'), u'jul') + self.assertEquals(dateformat.format(my_birthday, 'n'), u'7') + self.assertEquals(dateformat.format(my_birthday, 'N'), u'July') + + def test_time_formats(self): + my_birthday = datetime(1979, 7, 8, 22, 00) + + self.assertEquals(dateformat.format(my_birthday, 'P'), u'10 p.m.') + self.assertEquals(dateformat.format(my_birthday, 's'), u'00') + self.assertEquals(dateformat.format(my_birthday, 'S'), u'th') + self.assertEquals(dateformat.format(my_birthday, 't'), u'31') + self.assertEquals(dateformat.format(my_birthday, 'w'), u'0') + self.assertEquals(dateformat.format(my_birthday, 'W'), u'27') + self.assertEquals(dateformat.format(my_birthday, 'y'), u'79') + self.assertEquals(dateformat.format(my_birthday, 'Y'), u'1979') + self.assertEquals(dateformat.format(my_birthday, 'z'), u'189') + + def test_dateformat(self): + my_birthday = datetime(1979, 7, 8, 22, 00) + + self.assertEquals(dateformat.format(my_birthday, r'Y z \C\E\T'), u'1979 189 CET') + + self.assertEquals(dateformat.format(my_birthday, r'jS o\f F'), u'8th of July') + + def test_futuredates(self): + the_future = datetime(2100, 10, 25, 0, 00) + self.assertEquals(dateformat.format(the_future, r'Y'), u'2100') + + def test_timezones(self): + my_birthday = datetime(1979, 7, 8, 22, 00) + summertime = datetime(2005, 10, 30, 1, 00) + wintertime = datetime(2005, 10, 30, 4, 00) + timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456) + + if self.tz_tests: + self.assertEquals(dateformat.format(my_birthday, 'O'), u'+0100') + self.assertEquals(dateformat.format(my_birthday, 'r'), u'Sun, 8 Jul 1979 22:00:00 +0100') + self.assertEquals(dateformat.format(my_birthday, 'T'), u'CET') + self.assertEquals(dateformat.format(my_birthday, 'U'), u'300315600') + self.assertEquals(dateformat.format(timestamp, 'u'), u'123456') + self.assertEquals(dateformat.format(my_birthday, 'Z'), u'3600') + self.assertEquals(dateformat.format(summertime, 'I'), u'1') + self.assertEquals(dateformat.format(summertime, 'O'), u'+0200') + self.assertEquals(dateformat.format(wintertime, 'I'), u'0') + self.assertEquals(dateformat.format(wintertime, 'O'), u'+0100') diff --git a/parts/django/tests/regressiontests/utils/datetime_safe.py b/parts/django/tests/regressiontests/utils/datetime_safe.py new file mode 100644 index 0000000..458a6b7 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/datetime_safe.py @@ -0,0 +1,42 @@ +import unittest + +from datetime import date as original_date, datetime as original_datetime +from django.utils.datetime_safe import date, datetime + +class DatetimeTests(unittest.TestCase): + + def setUp(self): + self.just_safe = (1900, 1, 1) + self.just_unsafe = (1899, 12, 31, 23, 59, 59) + self.really_old = (20, 1, 1) + self.more_recent = (2006, 1, 1) + + def test_compare_datetimes(self): + self.assertEqual(original_datetime(*self.more_recent), datetime(*self.more_recent)) + self.assertEqual(original_datetime(*self.really_old), datetime(*self.really_old)) + self.assertEqual(original_date(*self.more_recent), date(*self.more_recent)) + self.assertEqual(original_date(*self.really_old), date(*self.really_old)) + + self.assertEqual(original_date(*self.just_safe).strftime('%Y-%m-%d'), date(*self.just_safe).strftime('%Y-%m-%d')) + self.assertEqual(original_datetime(*self.just_safe).strftime('%Y-%m-%d'), datetime(*self.just_safe).strftime('%Y-%m-%d')) + + def test_safe_strftime(self): + self.assertEquals(date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'), '1899-12-31 (weekday 0)') + self.assertEquals(date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'), '1900-01-01 (weekday 1)') + + self.assertEquals(datetime(*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1899-12-31 23:59:59 (weekday 0)') + self.assertEquals(datetime(*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1900-01-01 00:00:00 (weekday 1)') + + # %y will error before this date + self.assertEquals(date(*self.just_safe).strftime('%y'), '00') + self.assertEquals(datetime(*self.just_safe).strftime('%y'), '00') + + self.assertEquals(date(1850, 8, 2).strftime("%Y/%m/%d was a %A"), '1850/08/02 was a Friday') + + def test_zero_padding(self): + """ + Regression for #12524 + + Check that pre-1000AD dates are padded with zeros if necessary + """ + self.assertEquals(date(1, 1, 1).strftime("%Y/%m/%d was a %A"), '0001/01/01 was a Monday') diff --git a/parts/django/tests/regressiontests/utils/decorators.py b/parts/django/tests/regressiontests/utils/decorators.py new file mode 100644 index 0000000..ca9214f --- /dev/null +++ b/parts/django/tests/regressiontests/utils/decorators.py @@ -0,0 +1,19 @@ +from django.test import TestCase + +class DecoratorFromMiddlewareTests(TestCase): + """ + Tests for view decorators created using + ``django.utils.decorators.decorator_from_middleware``. + """ + + def test_process_view_middleware(self): + """ + Test a middleware that implements process_view. + """ + self.client.get('/utils/xview/') + + def test_callable_process_view_middleware(self): + """ + Test a middleware that implements process_view, operating on a callable class. + """ + self.client.get('/utils/class_xview/') diff --git a/parts/django/tests/regressiontests/utils/eggs/test_egg.egg b/parts/django/tests/regressiontests/utils/eggs/test_egg.egg Binary files differnew file mode 100644 index 0000000..9b08cc1 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/eggs/test_egg.egg diff --git a/parts/django/tests/regressiontests/utils/feedgenerator.py b/parts/django/tests/regressiontests/utils/feedgenerator.py new file mode 100644 index 0000000..9085d41 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/feedgenerator.py @@ -0,0 +1,63 @@ +import datetime +import unittest + +from django.utils import feedgenerator, tzinfo + +class FeedgeneratorTest(unittest.TestCase): + """ + Tests for the low-level syndication feed framework. + """ + + def test_get_tag_uri(self): + """ + Test get_tag_uri() correctly generates TagURIs. + """ + self.assertEqual( + feedgenerator.get_tag_uri('http://example.org/foo/bar#headline', datetime.date(2004, 10, 25)), + u'tag:example.org,2004-10-25:/foo/bar/headline') + + def test_get_tag_uri_with_port(self): + """ + Test that get_tag_uri() correctly generates TagURIs from URLs with port + numbers. + """ + self.assertEqual( + feedgenerator.get_tag_uri('http://www.example.org:8000/2008/11/14/django#headline', datetime.datetime(2008, 11, 14, 13, 37, 0)), + u'tag:www.example.org,2008-11-14:/2008/11/14/django/headline') + + def test_rfc2822_date(self): + """ + Test rfc2822_date() correctly formats datetime objects. + """ + self.assertEqual( + feedgenerator.rfc2822_date(datetime.datetime(2008, 11, 14, 13, 37, 0)), + "Fri, 14 Nov 2008 13:37:00 -0000" + ) + + def test_rfc2822_date_with_timezone(self): + """ + Test rfc2822_date() correctly formats datetime objects with tzinfo. + """ + self.assertEqual( + feedgenerator.rfc2822_date(datetime.datetime(2008, 11, 14, 13, 37, 0, tzinfo=tzinfo.FixedOffset(datetime.timedelta(minutes=60)))), + "Fri, 14 Nov 2008 13:37:00 +0100" + ) + + def test_rfc3339_date(self): + """ + Test rfc3339_date() correctly formats datetime objects. + """ + self.assertEqual( + feedgenerator.rfc3339_date(datetime.datetime(2008, 11, 14, 13, 37, 0)), + "2008-11-14T13:37:00Z" + ) + + def test_rfc3339_date_with_timezone(self): + """ + Test rfc3339_date() correctly formats datetime objects with tzinfo. + """ + self.assertEqual( + feedgenerator.rfc3339_date(datetime.datetime(2008, 11, 14, 13, 37, 0, tzinfo=tzinfo.FixedOffset(datetime.timedelta(minutes=120)))), + "2008-11-14T13:37:00+02:00" + ) + diff --git a/parts/django/tests/regressiontests/utils/functional.py b/parts/django/tests/regressiontests/utils/functional.py new file mode 100644 index 0000000..206a583 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/functional.py @@ -0,0 +1,10 @@ +import unittest + +from django.utils.functional import lazy + + +class FunctionalTestCase(unittest.TestCase): + def test_lazy(self): + t = lazy(lambda: tuple(range(3)), list, tuple) + for a, b in zip(t(), range(3)): + self.assertEqual(a, b) diff --git a/parts/django/tests/regressiontests/utils/html.py b/parts/django/tests/regressiontests/utils/html.py new file mode 100644 index 0000000..a9b0d33 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/html.py @@ -0,0 +1,111 @@ +import unittest + +from django.utils import html + +class TestUtilsHtml(unittest.TestCase): + + def check_output(self, function, value, output=None): + """ + Check that function(value) equals output. If output is None, + check that function(value) equals value. + """ + if output is None: + output = value + self.assertEqual(function(value), output) + + def test_escape(self): + f = html.escape + items = ( + ('&','&'), + ('<', '<'), + ('>', '>'), + ('"', '"'), + ("'", '''), + ) + # Substitution patterns for testing the above items. + patterns = ("%s", "asdf%sfdsa", "%s1", "1%sb") + for value, output in items: + for pattern in patterns: + self.check_output(f, pattern % value, pattern % output) + # Check repeated values. + self.check_output(f, value * 2, output * 2) + # Verify it doesn't double replace &. + self.check_output(f, '<&', '<&') + + def test_linebreaks(self): + f = html.linebreaks + items = ( + ("para1\n\npara2\r\rpara3", "<p>para1</p>\n\n<p>para2</p>\n\n<p>para3</p>"), + ("para1\nsub1\rsub2\n\npara2", "<p>para1<br />sub1<br />sub2</p>\n\n<p>para2</p>"), + ("para1\r\n\r\npara2\rsub1\r\rpara4", "<p>para1</p>\n\n<p>para2<br />sub1</p>\n\n<p>para4</p>"), + ("para1\tmore\n\npara2", "<p>para1\tmore</p>\n\n<p>para2</p>"), + ) + for value, output in items: + self.check_output(f, value, output) + + def test_strip_tags(self): + f = html.strip_tags + items = ( + ('<adf>a', 'a'), + ('</adf>a', 'a'), + ('<asdf><asdf>e', 'e'), + ('<f', '<f'), + ('</fe', '</fe'), + ('<x>b<y>', 'b'), + ) + for value, output in items: + self.check_output(f, value, output) + + def test_strip_spaces_between_tags(self): + f = html.strip_spaces_between_tags + # Strings that should come out untouched. + items = (' <adf>', '<adf> ', ' </adf> ', ' <f> x</f>') + for value in items: + self.check_output(f, value) + # Strings that have spaces to strip. + items = ( + ('<d> </d>', '<d></d>'), + ('<p>hello </p>\n<p> world</p>', '<p>hello </p><p> world</p>'), + ('\n<p>\t</p>\n<p> </p>\n', '\n<p></p><p></p>\n'), + ) + for value, output in items: + self.check_output(f, value, output) + + def test_strip_entities(self): + f = html.strip_entities + # Strings that should come out untouched. + values = ("&", "&a", "&a", "a&#a") + for value in values: + self.check_output(f, value) + # Valid entities that should be stripped from the patterns. + entities = ("", "", "&a;", "&fdasdfasdfasdf;") + patterns = ( + ("asdf %(entity)s ", "asdf "), + ("%(entity)s%(entity)s", ""), + ("&%(entity)s%(entity)s", "&"), + ("%(entity)s3", "3"), + ) + for entity in entities: + for in_pattern, output in patterns: + self.check_output(f, in_pattern % {'entity': entity}, output) + + def test_fix_ampersands(self): + f = html.fix_ampersands + # Strings without ampersands or with ampersands already encoded. + values = ("a", "b", "&a;", "& &x; ", "asdf") + patterns = ( + ("%s", "%s"), + ("&%s", "&%s"), + ("&%s&", "&%s&"), + ) + for value in values: + for in_pattern, out_pattern in patterns: + self.check_output(f, in_pattern % value, out_pattern % value) + # Strings with ampersands that need encoding. + items = ( + ("&#;", "&#;"), + ("ͫ ;", "&#875 ;"), + ("abc;", "&#4abc;"), + ) + for value, output in items: + self.check_output(f, value, output) diff --git a/parts/django/tests/regressiontests/utils/models.py b/parts/django/tests/regressiontests/utils/models.py new file mode 100644 index 0000000..97a72ba --- /dev/null +++ b/parts/django/tests/regressiontests/utils/models.py @@ -0,0 +1 @@ +# Test runner needs a models.py file. diff --git a/parts/django/tests/regressiontests/utils/module_loading.py b/parts/django/tests/regressiontests/utils/module_loading.py new file mode 100644 index 0000000..8cbefbb --- /dev/null +++ b/parts/django/tests/regressiontests/utils/module_loading.py @@ -0,0 +1,114 @@ +import os +import sys +import unittest +from zipimport import zipimporter + +from django.utils.importlib import import_module +from django.utils.module_loading import module_has_submodule + +class DefaultLoader(unittest.TestCase): + def test_loader(self): + "Normal module existence can be tested" + test_module = import_module('regressiontests.utils.test_module') + + # An importable child + self.assertTrue(module_has_submodule(test_module, 'good_module')) + mod = import_module('regressiontests.utils.test_module.good_module') + self.assertEqual(mod.content, 'Good Module') + + # A child that exists, but will generate an import error if loaded + self.assertTrue(module_has_submodule(test_module, 'bad_module')) + self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.bad_module') + + # A child that doesn't exist + self.assertFalse(module_has_submodule(test_module, 'no_such_module')) + self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.no_such_module') + +class EggLoader(unittest.TestCase): + def setUp(self): + self.old_path = sys.path[:] + self.egg_dir = '%s/eggs' % os.path.dirname(__file__) + + def tearDown(self): + sys.path = self.old_path + sys.path_importer_cache.clear() + + sys.modules.pop('egg_module.sub1.sub2.bad_module', None) + sys.modules.pop('egg_module.sub1.sub2.good_module', None) + sys.modules.pop('egg_module.sub1.sub2', None) + sys.modules.pop('egg_module.sub1', None) + sys.modules.pop('egg_module.bad_module', None) + sys.modules.pop('egg_module.good_module', None) + sys.modules.pop('egg_module', None) + + def test_shallow_loader(self): + "Module existence can be tested inside eggs" + egg_name = '%s/test_egg.egg' % self.egg_dir + sys.path.append(egg_name) + egg_module = import_module('egg_module') + + # An importable child + self.assertTrue(module_has_submodule(egg_module, 'good_module')) + mod = import_module('egg_module.good_module') + self.assertEqual(mod.content, 'Good Module') + + # A child that exists, but will generate an import error if loaded + self.assertTrue(module_has_submodule(egg_module, 'bad_module')) + self.assertRaises(ImportError, import_module, 'egg_module.bad_module') + + # A child that doesn't exist + self.assertFalse(module_has_submodule(egg_module, 'no_such_module')) + self.assertRaises(ImportError, import_module, 'egg_module.no_such_module') + + def test_deep_loader(self): + "Modules deep inside an egg can still be tested for existence" + egg_name = '%s/test_egg.egg' % self.egg_dir + sys.path.append(egg_name) + egg_module = import_module('egg_module.sub1.sub2') + + # An importable child + self.assertTrue(module_has_submodule(egg_module, 'good_module')) + mod = import_module('egg_module.sub1.sub2.good_module') + self.assertEqual(mod.content, 'Deep Good Module') + + # A child that exists, but will generate an import error if loaded + self.assertTrue(module_has_submodule(egg_module, 'bad_module')) + self.assertRaises(ImportError, import_module, 'egg_module.sub1.sub2.bad_module') + + # A child that doesn't exist + self.assertFalse(module_has_submodule(egg_module, 'no_such_module')) + self.assertRaises(ImportError, import_module, 'egg_module.sub1.sub2.no_such_module') + +class TestFinder(object): + def __init__(self, *args, **kwargs): + self.importer = zipimporter(*args, **kwargs) + + def find_module(self, path): + importer = self.importer.find_module(path) + if importer is None: + return + return TestLoader(importer) + +class TestLoader(object): + def __init__(self, importer): + self.importer = importer + + def load_module(self, name): + mod = self.importer.load_module(name) + mod.__loader__ = self + return mod + +class CustomLoader(EggLoader): + """The Custom Loader test is exactly the same as the EggLoader, but + it uses a custom defined Loader and Finder that is intentionally + split into two classes. Although the EggLoader combines both functions + into one class, this isn't required. + """ + def setUp(self): + super(CustomLoader, self).setUp() + sys.path_hooks.insert(0, TestFinder) + sys.path_importer_cache.clear() + + def tearDown(self): + super(CustomLoader, self).tearDown() + sys.path_hooks.pop(0) diff --git a/parts/django/tests/regressiontests/utils/simplelazyobject.py b/parts/django/tests/regressiontests/utils/simplelazyobject.py new file mode 100644 index 0000000..4a930dd --- /dev/null +++ b/parts/django/tests/regressiontests/utils/simplelazyobject.py @@ -0,0 +1,77 @@ +import unittest + +import django.utils.copycompat as copy +from django.utils.functional import SimpleLazyObject + +class _ComplexObject(object): + def __init__(self, name): + self.name = name + + def __eq__(self, other): + return self.name == other.name + + def __hash__(self): + return hash(self.name) + + def __str__(self): + return "I am _ComplexObject(%r)" % self.name + + def __unicode__(self): + return unicode(self.name) + + def __repr__(self): + return "_ComplexObject(%r)" % self.name + +complex_object = lambda: _ComplexObject("joe") + +class TestUtilsSimpleLazyObject(unittest.TestCase): + """ + Tests for SimpleLazyObject + """ + # Note that concrete use cases for SimpleLazyObject are also found in the + # auth context processor tests (unless the implementation of that function + # is changed). + + def test_equality(self): + self.assertEqual(complex_object(), SimpleLazyObject(complex_object)) + self.assertEqual(SimpleLazyObject(complex_object), complex_object()) + + def test_hash(self): + # hash() equality would not be true for many objects, but it should be + # for _ComplexObject + self.assertEqual(hash(complex_object()), + hash(SimpleLazyObject(complex_object))) + + def test_repr(self): + # For debugging, it will really confuse things if there is no clue that + # SimpleLazyObject is actually a proxy object. So we don't + # proxy __repr__ + self.assert_("SimpleLazyObject" in repr(SimpleLazyObject(complex_object))) + + def test_str(self): + self.assertEqual("I am _ComplexObject('joe')", str(SimpleLazyObject(complex_object))) + + def test_unicode(self): + self.assertEqual(u"joe", unicode(SimpleLazyObject(complex_object))) + + def test_class(self): + # This is important for classes that use __class__ in things like + # equality tests. + self.assertEqual(_ComplexObject, SimpleLazyObject(complex_object).__class__) + + def test_deepcopy(self): + # Check that we *can* do deep copy, and that it returns the right + # objects. + + # First, for an unevaluated SimpleLazyObject + s = SimpleLazyObject(complex_object) + assert s._wrapped is None + s2 = copy.deepcopy(s) + assert s._wrapped is None # something has gone wrong is s is evaluated + self.assertEqual(s2, complex_object()) + + # Second, for an evaluated SimpleLazyObject + name = s.name # evaluate + assert s._wrapped is not None + s3 = copy.deepcopy(s) + self.assertEqual(s3, complex_object()) diff --git a/parts/django/tests/regressiontests/utils/termcolors.py b/parts/django/tests/regressiontests/utils/termcolors.py new file mode 100644 index 0000000..ccae32c --- /dev/null +++ b/parts/django/tests/regressiontests/utils/termcolors.py @@ -0,0 +1,149 @@ +import unittest + +from django.utils.termcolors import parse_color_setting, PALETTES, DEFAULT_PALETTE, LIGHT_PALETTE, DARK_PALETTE, NOCOLOR_PALETTE + +class TermColorTests(unittest.TestCase): + + def test_empty_string(self): + self.assertEquals(parse_color_setting(''), PALETTES[DEFAULT_PALETTE]) + + def test_simple_palette(self): + self.assertEquals(parse_color_setting('light'), PALETTES[LIGHT_PALETTE]) + self.assertEquals(parse_color_setting('dark'), PALETTES[DARK_PALETTE]) + self.assertEquals(parse_color_setting('nocolor'), None) + + def test_fg(self): + self.assertEquals(parse_color_setting('error=green'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green'})) + + def test_fg_bg(self): + self.assertEquals(parse_color_setting('error=green/blue'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'bg':'blue'})) + + def test_fg_opts(self): + self.assertEquals(parse_color_setting('error=green,blink'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'opts': ('blink',)})) + self.assertEquals(parse_color_setting('error=green,bold,blink'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'opts': ('blink','bold')})) + + def test_fg_bg_opts(self): + self.assertEquals(parse_color_setting('error=green/blue,blink'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'bg':'blue', 'opts': ('blink',)})) + self.assertEquals(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.assertEquals(parse_color_setting('light;error=green'), + dict(PALETTES[LIGHT_PALETTE], + ERROR={'fg':'green'})) + + def test_override_nocolor(self): + self.assertEquals(parse_color_setting('nocolor;error=green'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg': 'green'})) + + def test_reverse_override(self): + self.assertEquals(parse_color_setting('error=green;light'), PALETTES[LIGHT_PALETTE]) + + def test_multiple_roles(self): + self.assertEquals(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.assertEquals(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.assertEquals(parse_color_setting(';'), None) + self.assertEquals(parse_color_setting('light;'), PALETTES[LIGHT_PALETTE]) + self.assertEquals(parse_color_setting(';;;'), None) + + def test_empty_options(self): + self.assertEquals(parse_color_setting('error=green,'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green'})) + self.assertEquals(parse_color_setting('error=green,,,'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green'})) + self.assertEquals(parse_color_setting('error=green,,blink,,'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'opts': ('blink',)})) + + def test_bad_palette(self): + self.assertEquals(parse_color_setting('unknown'), None) + + def test_bad_role(self): + self.assertEquals(parse_color_setting('unknown='), None) + self.assertEquals(parse_color_setting('unknown=green'), None) + self.assertEquals(parse_color_setting('unknown=green;sql_field=blue'), + dict(PALETTES[NOCOLOR_PALETTE], + SQL_FIELD={'fg':'blue'})) + + def test_bad_color(self): + self.assertEquals(parse_color_setting('error='), None) + self.assertEquals(parse_color_setting('error=;sql_field=blue'), + dict(PALETTES[NOCOLOR_PALETTE], + SQL_FIELD={'fg':'blue'})) + self.assertEquals(parse_color_setting('error=unknown'), None) + self.assertEquals(parse_color_setting('error=unknown;sql_field=blue'), + dict(PALETTES[NOCOLOR_PALETTE], + SQL_FIELD={'fg':'blue'})) + self.assertEquals(parse_color_setting('error=green/unknown'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green'})) + self.assertEquals(parse_color_setting('error=green/blue/something'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'bg': 'blue'})) + self.assertEquals(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.assertEquals(parse_color_setting('error=green,unknown'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green'})) + self.assertEquals(parse_color_setting('error=green,unknown,blink'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'opts': ('blink',)})) + + def test_role_case(self): + self.assertEquals(parse_color_setting('ERROR=green'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green'})) + self.assertEquals(parse_color_setting('eRrOr=green'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green'})) + + def test_color_case(self): + self.assertEquals(parse_color_setting('error=GREEN'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green'})) + self.assertEquals(parse_color_setting('error=GREEN/BLUE'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'bg':'blue'})) + + self.assertEquals(parse_color_setting('error=gReEn'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green'})) + self.assertEquals(parse_color_setting('error=gReEn/bLuE'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'bg':'blue'})) + + def test_opts_case(self): + self.assertEquals(parse_color_setting('error=green,BLINK'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'opts': ('blink',)})) + + self.assertEquals(parse_color_setting('error=green,bLiNk'), + dict(PALETTES[NOCOLOR_PALETTE], + ERROR={'fg':'green', 'opts': ('blink',)})) diff --git a/parts/django/tests/regressiontests/utils/test_module/__init__.py b/parts/django/tests/regressiontests/utils/test_module/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/test_module/__init__.py diff --git a/parts/django/tests/regressiontests/utils/test_module/bad_module.py b/parts/django/tests/regressiontests/utils/test_module/bad_module.py new file mode 100644 index 0000000..cc0cd16 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/test_module/bad_module.py @@ -0,0 +1,3 @@ +import a_package_name_that_does_not_exist + +content = 'Bad Module'
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/utils/test_module/good_module.py b/parts/django/tests/regressiontests/utils/test_module/good_module.py new file mode 100644 index 0000000..0ca6898 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/test_module/good_module.py @@ -0,0 +1 @@ +content = 'Good Module'
\ No newline at end of file diff --git a/parts/django/tests/regressiontests/utils/tests.py b/parts/django/tests/regressiontests/utils/tests.py new file mode 100644 index 0000000..6d3bbfa --- /dev/null +++ b/parts/django/tests/regressiontests/utils/tests.py @@ -0,0 +1,18 @@ +""" +Tests for django.utils. +""" + +from dateformat import * +from feedgenerator import * +from module_loading import * +from termcolors import * +from html import * +from checksums import * +from text import * +from simplelazyobject import * +from decorators import * +from functional import * +from timesince import * +from datastructures import * +from tzinfo import * +from datetime_safe import * diff --git a/parts/django/tests/regressiontests/utils/text.py b/parts/django/tests/regressiontests/utils/text.py new file mode 100644 index 0000000..e7d2d38 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/text.py @@ -0,0 +1,20 @@ +import unittest + +from django.utils import text + +class TestUtilsText(unittest.TestCase): + def test_truncate_words(self): + self.assertEqual(u'The quick brown fox jumped over the lazy dog.', + text.truncate_words(u'The quick brown fox jumped over the lazy dog.', 10)) + self.assertEqual(u'The quick brown fox ...', + text.truncate_words('The quick brown fox jumped over the lazy dog.', 4)) + self.assertEqual(u'The quick brown fox ....', + text.truncate_words('The quick brown fox jumped over the lazy dog.', 4, '....')) + self.assertEqual(u'<p><strong><em>The quick brown fox jumped over the lazy dog.</em></strong></p>', + text.truncate_html_words('<p><strong><em>The quick brown fox jumped over the lazy dog.</em></strong></p>', 10)) + self.assertEqual(u'<p><strong><em>The quick brown fox ...</em></strong></p>', + text.truncate_html_words('<p><strong><em>The quick brown fox jumped over the lazy dog.</em></strong></p>', 4)) + self.assertEqual(u'<p><strong><em>The quick brown fox ....</em></strong></p>', + text.truncate_html_words('<p><strong><em>The quick brown fox jumped over the lazy dog.</em></strong></p>', 4, '....')) + self.assertEqual(u'<p><strong><em>The quick brown fox</em></strong></p>', + text.truncate_html_words('<p><strong><em>The quick brown fox jumped over the lazy dog.</em></strong></p>', 4, None)) diff --git a/parts/django/tests/regressiontests/utils/timesince.py b/parts/django/tests/regressiontests/utils/timesince.py new file mode 100644 index 0000000..774aa3f --- /dev/null +++ b/parts/django/tests/regressiontests/utils/timesince.py @@ -0,0 +1,107 @@ +import datetime +import unittest + +from django.utils.timesince import timesince, timeuntil +from django.utils.tzinfo import LocalTimezone, FixedOffset + +class TimesinceTests(unittest.TestCase): + + def setUp(self): + self.t = datetime.datetime(2007, 8, 14, 13, 46, 0) + self.onemicrosecond = datetime.timedelta(microseconds=1) + self.onesecond = datetime.timedelta(seconds=1) + self.oneminute = datetime.timedelta(minutes=1) + self.onehour = datetime.timedelta(hours=1) + self.oneday = datetime.timedelta(days=1) + self.oneweek = datetime.timedelta(days=7) + self.onemonth = datetime.timedelta(days=30) + self.oneyear = datetime.timedelta(days=365) + + def test_equal_datetimes(self): + """ equal datetimes. """ + self.assertEquals(timesince(self.t, self.t), u'0 minutes') + + def test_ignore_microseconds_and_seconds(self): + """ Microseconds and seconds are ignored. """ + self.assertEquals(timesince(self.t, self.t+self.onemicrosecond), + u'0 minutes') + self.assertEquals(timesince(self.t, self.t+self.onesecond), + u'0 minutes') + + def test_other_units(self): + """ Test other units. """ + self.assertEquals(timesince(self.t, self.t+self.oneminute), + u'1 minute') + self.assertEquals(timesince(self.t, self.t+self.onehour), u'1 hour') + self.assertEquals(timesince(self.t, self.t+self.oneday), u'1 day') + self.assertEquals(timesince(self.t, self.t+self.oneweek), u'1 week') + self.assertEquals(timesince(self.t, self.t+self.onemonth), + u'1 month') + self.assertEquals(timesince(self.t, self.t+self.oneyear), u'1 year') + + def test_multiple_units(self): + """ Test multiple units. """ + self.assertEquals(timesince(self.t, + self.t+2*self.oneday+6*self.onehour), u'2 days, 6 hours') + self.assertEquals(timesince(self.t, + self.t+2*self.oneweek+2*self.oneday), u'2 weeks, 2 days') + + def test_display_first_unit(self): + """ + If the two differing units aren't adjacent, only the first unit is + displayed. + """ + self.assertEquals(timesince(self.t, + self.t+2*self.oneweek+3*self.onehour+4*self.oneminute), + u'2 weeks') + + self.assertEquals(timesince(self.t, + self.t+4*self.oneday+5*self.oneminute), u'4 days') + + def test_display_second_before_first(self): + """ + When the second date occurs before the first, we should always + get 0 minutes. + """ + self.assertEquals(timesince(self.t, self.t-self.onemicrosecond), + u'0 minutes') + self.assertEquals(timesince(self.t, self.t-self.onesecond), + u'0 minutes') + self.assertEquals(timesince(self.t, self.t-self.oneminute), + u'0 minutes') + self.assertEquals(timesince(self.t, self.t-self.onehour), + u'0 minutes') + self.assertEquals(timesince(self.t, self.t-self.oneday), + u'0 minutes') + self.assertEquals(timesince(self.t, self.t-self.oneweek), + u'0 minutes') + self.assertEquals(timesince(self.t, self.t-self.onemonth), + u'0 minutes') + self.assertEquals(timesince(self.t, self.t-self.oneyear), + u'0 minutes') + self.assertEquals(timesince(self.t, + self.t-2*self.oneday-6*self.onehour), u'0 minutes') + self.assertEquals(timesince(self.t, + self.t-2*self.oneweek-2*self.oneday), u'0 minutes') + self.assertEquals(timesince(self.t, + self.t-2*self.oneweek-3*self.onehour-4*self.oneminute), + u'0 minutes') + self.assertEquals(timesince(self.t, + self.t-4*self.oneday-5*self.oneminute), u'0 minutes') + + def test_different_timezones(self): + """ When using two different timezones. """ + now = datetime.datetime.now() + now_tz = datetime.datetime.now(LocalTimezone(now)) + now_tz_i = datetime.datetime.now(FixedOffset((3 * 60) + 15)) + + self.assertEquals(timesince(now), u'0 minutes') + self.assertEquals(timesince(now_tz), u'0 minutes') + self.assertEquals(timeuntil(now_tz, now_tz_i), u'0 minutes') + + def test_both_date_objects(self): + """ Timesince should work with both date objects (#9672) """ + today = datetime.date.today() + self.assertEquals(timeuntil(today+self.oneday, today), u'1 day') + self.assertEquals(timeuntil(today-self.oneday, today), u'0 minutes') + self.assertEquals(timeuntil(today+self.oneweek, today), u'1 week') diff --git a/parts/django/tests/regressiontests/utils/tzinfo.py b/parts/django/tests/regressiontests/utils/tzinfo.py new file mode 100644 index 0000000..edbb9a7 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/tzinfo.py @@ -0,0 +1,18 @@ +import unittest + +from django.utils.tzinfo import FixedOffset + +class TzinfoTests(unittest.TestCase): + + def test_fixedoffset(self): + self.assertEquals(repr(FixedOffset(0)), '+0000') + self.assertEquals(repr(FixedOffset(60)), '+0100') + self.assertEquals(repr(FixedOffset(-60)), '-0100') + self.assertEquals(repr(FixedOffset(280)), '+0440') + self.assertEquals(repr(FixedOffset(-280)), '-0440') + self.assertEquals(repr(FixedOffset(-78.4)), '-0118') + self.assertEquals(repr(FixedOffset(78.4)), '+0118') + self.assertEquals(repr(FixedOffset(-5.5*60)), '-0530') + self.assertEquals(repr(FixedOffset(5.5*60)), '+0530') + self.assertEquals(repr(FixedOffset(-.5*60)), '-0030') + self.assertEquals(repr(FixedOffset(.5*60)), '+0030') diff --git a/parts/django/tests/regressiontests/utils/urls.py b/parts/django/tests/regressiontests/utils/urls.py new file mode 100644 index 0000000..ba09d14 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/urls.py @@ -0,0 +1,8 @@ +from django.conf.urls.defaults import * + +import views + +urlpatterns = patterns('', + (r'^xview/$', views.xview), + (r'^class_xview/$', views.class_xview), +) diff --git a/parts/django/tests/regressiontests/utils/views.py b/parts/django/tests/regressiontests/utils/views.py new file mode 100644 index 0000000..ef97c65 --- /dev/null +++ b/parts/django/tests/regressiontests/utils/views.py @@ -0,0 +1,17 @@ +from django.http import HttpResponse +from django.utils.decorators import decorator_from_middleware +from django.middleware.doc import XViewMiddleware + + +xview_dec = decorator_from_middleware(XViewMiddleware) + +def xview(request): + return HttpResponse() +xview = xview_dec(xview) + + +class ClassXView(object): + def __call__(self, request): + return HttpResponse() + +class_xview = xview_dec(ClassXView()) |