Merge branch 'master' into schema-alteration

8 files changed, 122 insertions, 21 deletions

diff --git a/tests/regressiontests/utils/archive.py b/tests/regressiontests/utils/archive.py
index 0927c624f3..5575f340f6 100644
--- a/tests/regressiontests/utils/archive.py
+++ b/tests/regressiontests/utils/archive.py
@@ -27,12 +27,14 @@ class ArchiveTester(object):
         os.chdir(self.old_cwd)
 
     def test_extract_method(self):
-        Archive(self.archive).extract(self.tmpdir)
+        with Archive(self.archive) as archive:
+            archive.extract(self.tmpdir)
         self.check_files(self.tmpdir)
 
     def test_extract_method_no_to_path(self):
         os.chdir(self.tmpdir)
-        Archive(self.archive_path).extract()
+        with Archive(self.archive_path) as archive:
+            archive.extract()
         self.check_files(self.tmpdir)
 
     def test_extract_function(self):
diff --git a/tests/regressiontests/utils/crypto.py b/tests/regressiontests/utils/crypto.py
index 52a286cb27..4c6b722ca9 100644
--- a/tests/regressiontests/utils/crypto.py
+++ b/tests/regressiontests/utils/crypto.py
@@ -6,7 +6,17 @@ import timeit
 import hashlib
 
 from django.utils import unittest
-from django.utils.crypto import pbkdf2
+from django.utils.crypto import constant_time_compare, pbkdf2
+
+
+class TestUtilsCryptoMisc(unittest.TestCase):
+
+    def test_constant_time_compare(self):
+        # It's hard to test for constant time, just test the result.
+        self.assertTrue(constant_time_compare(b'spam', b'spam'))
+        self.assertFalse(constant_time_compare(b'spam', b'eggs'))
+        self.assertTrue(constant_time_compare('spam', 'spam'))
+        self.assertFalse(constant_time_compare('spam', 'eggs'))
 
 
 class TestUtilsCryptoPBKDF2(unittest.TestCase):
diff --git a/tests/regressiontests/utils/dateparse.py b/tests/regressiontests/utils/dateparse.py
new file mode 100644
index 0000000000..1a6ca646b8
--- /dev/null
+++ b/tests/regressiontests/utils/dateparse.py
@@ -0,0 +1,44 @@
+from __future__ import unicode_literals
+
+from datetime import date, time, datetime
+
+from django.utils.dateparse import parse_date, parse_time, parse_datetime
+from django.utils import unittest
+from django.utils.tzinfo import FixedOffset
+
+
+class DateParseTests(unittest.TestCase):
+
+    def test_parse_date(self):
+        # Valid inputs
+        self.assertEqual(parse_date('2012-04-23'), date(2012, 4, 23))
+        self.assertEqual(parse_date('2012-4-9'), date(2012, 4, 9))
+        # Invalid inputs
+        self.assertEqual(parse_date('20120423'), None)
+        self.assertRaises(ValueError, parse_date, '2012-04-56')
+
+    def test_parse_time(self):
+        # Valid inputs
+        self.assertEqual(parse_time('09:15:00'), time(9, 15))
+        self.assertEqual(parse_time('10:10'), time(10, 10))
+        self.assertEqual(parse_time('10:20:30.400'), time(10, 20, 30, 400000))
+        self.assertEqual(parse_time('4:8:16'), time(4, 8, 16))
+        # Invalid inputs
+        self.assertEqual(parse_time('091500'), None)
+        self.assertRaises(ValueError, parse_time, '09:15:90')
+
+    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, FixedOffset(0)))
+        self.assertEqual(parse_datetime('2012-4-9 4:8:16-0320'),
+            datetime(2012, 4, 9, 4, 8, 16, 0, FixedOffset(-200)))
+        self.assertEqual(parse_datetime('2012-04-23T10:20:30.400+02:30'),
+            datetime(2012, 4, 23, 10, 20, 30, 400000, FixedOffset(150)))
+        # Invalid inputs
+        self.assertEqual(parse_datetime('20120423091500'), None)
+        self.assertRaises(ValueError, parse_datetime, '2012-04-56T09:15:90')
diff --git a/tests/regressiontests/utils/encoding.py b/tests/regressiontests/utils/encoding.py
new file mode 100644
index 0000000000..d191845518
--- /dev/null
+++ b/tests/regressiontests/utils/encoding.py
@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.utils import unittest
+from django.utils.encoding import force_bytes
+
+
+class TestEncodingUtils(unittest.TestCase):
+    def test_force_bytes_exception(self):
+        """
+        Test that force_bytes knows how to convert to bytes an exception
+        containing non-ASCII characters in its args.
+        """
+        error_msg = "This is an exception, voilà"
+        exc = ValueError(error_msg)
+        result = force_bytes(exc)
+        self.assertEqual(result, error_msg.encode('utf-8'))
diff --git a/tests/regressiontests/utils/html.py b/tests/regressiontests/utils/html.py
index fe40d4eaae..98df80a5e2 100644
--- a/tests/regressiontests/utils/html.py
+++ b/tests/regressiontests/utils/html.py
@@ -146,3 +146,12 @@ class TestUtilsHtml(unittest.TestCase):
         )
         for value, output in items:
             self.check_output(f, value, output)
+
+    def test_remove_tags(self):
+        f = html.remove_tags
+        items = (
+            ("<b><i>Yes</i></b>", "b i", "Yes"),
+            ("<a>x</a> <p><b>y</b></p>", "a b", "x <p>y</p>"),
+        )
+        for value, tags, output in items:
+            self.assertEquals(f(value, tags), output)
diff --git a/tests/regressiontests/utils/module_loading.py b/tests/regressiontests/utils/module_loading.py
index cbd81c7294..dffb51966c 100644
--- a/tests/regressiontests/utils/module_loading.py
+++ b/tests/regressiontests/utils/module_loading.py
@@ -109,7 +109,12 @@ class ProxyFinder(object):
     def find_module(self, fullname, path=None):
         tail = fullname.rsplit('.', 1)[-1]
         try:
-            self._cache[fullname] = imp.find_module(tail, path)
+            fd, fn, info = imp.find_module(tail, path)
+            if fullname in self._cache:
+                old_fd = self._cache[fullname][0]
+                if old_fd:
+                    old_fd.close()
+            self._cache[fullname] = (fd, fn, info)
         except ImportError:
             return None
         else:
@@ -119,7 +124,11 @@ class ProxyFinder(object):
         if fullname in sys.modules:
             return sys.modules[fullname]
         fd, fn, info = self._cache[fullname]
-        return imp.load_module(fullname, fd, fn, info)
+        try:
+            return imp.load_module(fullname, fd, fn, info)
+        finally:
+            if fd:
+                fd.close()
 
 class TestFinder(object):
     def __init__(self, *args, **kwargs):
diff --git a/tests/regressiontests/utils/tests.py b/tests/regressiontests/utils/tests.py
index a7deeeefae..f4fa75b177 100644
--- a/tests/regressiontests/utils/tests.py
+++ b/tests/regressiontests/utils/tests.py
@@ -3,26 +3,28 @@ Tests for django.utils.
 """
 from __future__ import absolute_import
 
+from .archive import TestBzip2Tar, TestGzipTar, TestTar, TestZip
+from .baseconv import TestBaseConv
+from .checksums import TestUtilsChecksums
+from .crypto import TestUtilsCryptoMisc, TestUtilsCryptoPBKDF2
+from .datastructures import (DictWrapperTests, ImmutableListTests,
+    MergeDictTests, MultiValueDictTests, SortedDictTests)
 from .dateformat import DateFormatTests
+from .dateparse import DateParseTests
+from .datetime_safe import DatetimeTests
+from .decorators import DecoratorFromMiddlewareTests
+from .encoding import TestEncodingUtils
 from .feedgenerator import FeedgeneratorTest
-from .module_loading import DefaultLoader, EggLoader, CustomLoader
-from .termcolors import TermColorTests
+from .functional import FunctionalTestCase
 from .html import TestUtilsHtml
 from .http import TestUtilsHttp
-from .checksums import TestUtilsChecksums
-from .text import TestUtilsText
+from .ipv6 import TestUtilsIPv6
+from .jslex import JsToCForGettextTest, JsTokensTest
+from .module_loading import CustomLoader, DefaultLoader, EggLoader
+from .regex_helper import NormalizeTests
 from .simplelazyobject import TestUtilsSimpleLazyObject
-from .decorators import DecoratorFromMiddlewareTests
-from .functional import FunctionalTestCase
+from .termcolors import TermColorTests
+from .text import TestUtilsText
 from .timesince import TimesinceTests
-from .datastructures import (MultiValueDictTests, SortedDictTests,
-    DictWrapperTests, ImmutableListTests, MergeDictTests)
-from .tzinfo import TzinfoTests
-from .datetime_safe import DatetimeTests
-from .baseconv import TestBaseConv
-from .jslex import JsTokensTest, JsToCForGettextTest
-from .ipv6 import TestUtilsIPv6
 from .timezone import TimezoneTests
-from .crypto import TestUtilsCryptoPBKDF2
-from .archive import TestZip, TestTar, TestGzipTar, TestBzip2Tar
-from .regex_helper import NormalizeTests
+from .tzinfo import TzinfoTests
diff --git a/tests/regressiontests/utils/text.py b/tests/regressiontests/utils/text.py
index dd6de63841..ebf67952f9 100644
--- a/tests/regressiontests/utils/text.py
+++ b/tests/regressiontests/utils/text.py
@@ -113,3 +113,11 @@ class TestUtilsText(SimpleTestCase):
         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)
+
+    def test_slugify(self):
+        items = (
+            ('Hello, World!', 'hello-world'),
+            ('spam & eggs', 'spam-eggs'),
+        )
+        for value, output in items:
+            self.assertEqual(text.slugify(value), output)