Merge branch 'master' of github.com:django/django into schema-alteration

Conflicts:
	django/db/backends/postgresql_psycopg2/base.py

4 files changed, 71 insertions, 53 deletions

diff --git a/tests/regressiontests/utils/datastructures.py b/tests/regressiontests/utils/datastructures.py
index 000f7f76a1..dbc65d37a8 100644
--- a/tests/regressiontests/utils/datastructures.py
+++ b/tests/regressiontests/utils/datastructures.py
@@ -4,10 +4,12 @@ Tests for stuff in django.utils.datastructures.
 
 import copy
 import pickle
+import warnings
 
 from django.test import SimpleTestCase
-from django.utils.datastructures import (DictWrapper, DotExpandedDict,
-    ImmutableList, MultiValueDict, MultiValueDictKeyError, MergeDict, SortedDict)
+from django.utils.datastructures import (DictWrapper, ImmutableList,
+    MultiValueDict, MultiValueDictKeyError, MergeDict, SortedDict)
+from django.utils import six
 
 
 class SortedDictTests(SimpleTestCase):
@@ -24,19 +26,19 @@ class SortedDictTests(SimpleTestCase):
         self.d2[7] = 'seven'
 
     def test_basic_methods(self):
-        self.assertEqual(self.d1.keys(), [7, 1, 9])
-        self.assertEqual(self.d1.values(), ['seven', 'one', 'nine'])
-        self.assertEqual(self.d1.items(), [(7, 'seven'), (1, 'one'), (9, 'nine')])
+        self.assertEqual(list(six.iterkeys(self.d1)), [7, 1, 9])
+        self.assertEqual(list(six.itervalues(self.d1)), ['seven', 'one', 'nine'])
+        self.assertEqual(list(six.iteritems(self.d1)), [(7, 'seven'), (1, 'one'), (9, 'nine')])
 
     def test_overwrite_ordering(self):
-        """ Overwriting an item keeps it's place. """
+        """ Overwriting an item keeps its place. """
         self.d1[1] = 'ONE'
-        self.assertEqual(self.d1.values(), ['seven', 'ONE', 'nine'])
+        self.assertEqual(list(six.itervalues(self.d1)), ['seven', 'ONE', 'nine'])
 
     def test_append_items(self):
         """ New items go to the end. """
         self.d1[0] = 'nil'
-        self.assertEqual(self.d1.keys(), [7, 1, 9, 0])
+        self.assertEqual(list(six.iterkeys(self.d1)), [7, 1, 9, 0])
 
     def test_delete_and_insert(self):
         """
@@ -44,18 +46,22 @@ class SortedDictTests(SimpleTestCase):
         at the end.
         """
         del self.d2[7]
-        self.assertEqual(self.d2.keys(), [1, 9, 0])
+        self.assertEqual(list(six.iterkeys(self.d2)), [1, 9, 0])
         self.d2[7] = 'lucky number 7'
-        self.assertEqual(self.d2.keys(), [1, 9, 0, 7])
+        self.assertEqual(list(six.iterkeys(self.d2)), [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.assertEqual(self.d2.keys(), [1, 9, 0, 7])
+    if not six.PY3:
+        def test_change_keys(self):
+            """
+            Changing the keys won't do anything, it's only a copy of the
+            keys dict.
+
+            This test doesn't make sense under Python 3 because keys is
+            an iterator.
+            """
+            k = self.d2.keys()
+            k.remove(9)
+            self.assertEqual(self.d2.keys(), [1, 9, 0, 7])
 
     def test_init_keys(self):
         """
@@ -67,18 +73,18 @@ class SortedDictTests(SimpleTestCase):
         tuples = ((2, 'two'), (1, 'one'), (2, 'second-two'))
         d = SortedDict(tuples)
 
-        self.assertEqual(d.keys(), [2, 1])
+        self.assertEqual(list(six.iterkeys(d)), [2, 1])
 
         real_dict = dict(tuples)
-        self.assertEqual(sorted(real_dict.values()), ['one', 'second-two'])
+        self.assertEqual(sorted(six.itervalues(real_dict)), ['one', 'second-two'])
 
         # Here the order of SortedDict values *is* what we are testing
-        self.assertEqual(d.values(), ['second-two', 'one'])
+        self.assertEqual(list(six.itervalues(d)), ['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())
+        self.assertEqual(list(six.iterkeys(self.d1)), list(six.iterkeys(self.d1.copy())))
 
     def test_append(self):
         self.d1[13] = 'thirteen'
@@ -98,7 +104,7 @@ class SortedDictTests(SimpleTestCase):
         self.assertEqual(l - len(self.d1), 1)
 
     def test_dict_equality(self):
-        d = SortedDict((i, i) for i in xrange(3))
+        d = SortedDict((i, i) for i in range(3))
         self.assertEqual(d, {0: 0, 1: 1, 2: 2})
 
     def test_tuple_init(self):
@@ -114,14 +120,29 @@ class SortedDictTests(SimpleTestCase):
     def test_copy(self):
         orig = SortedDict(((1, "one"), (0, "zero"), (2, "two")))
         copied = copy.copy(orig)
-        self.assertEqual(orig.keys(), [1, 0, 2])
-        self.assertEqual(copied.keys(), [1, 0, 2])
+        self.assertEqual(list(six.iterkeys(orig)), [1, 0, 2])
+        self.assertEqual(list(six.iterkeys(copied)), [1, 0, 2])
 
     def test_clear(self):
         self.d1.clear()
         self.assertEqual(self.d1, {})
         self.assertEqual(self.d1.keyOrder, [])
 
+    def test_insert(self):
+        d = SortedDict()
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            d.insert(0, "hello", "world")
+        assert w[0].category is PendingDeprecationWarning
+
+    def test_value_for_index(self):
+        d = SortedDict({"a": 3})
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.assertEqual(d.value_for_index(0), 3)
+        assert w[0].category is PendingDeprecationWarning
+
+
 class MergeDictTests(SimpleTestCase):
 
     def test_simple_mergedict(self):
@@ -162,12 +183,12 @@ class MergeDictTests(SimpleTestCase):
         self.assertEqual(mm.getlist('key4'), ['value5', 'value6'])
         self.assertEqual(mm.getlist('undefined'), [])
 
-        self.assertEqual(sorted(mm.keys()), ['key1', 'key2', 'key4'])
-        self.assertEqual(len(mm.values()), 3)
+        self.assertEqual(sorted(six.iterkeys(mm)), ['key1', 'key2', 'key4'])
+        self.assertEqual(len(list(six.itervalues(mm))), 3)
 
-        self.assertTrue('value1' in mm.values())
+        self.assertTrue('value1' in six.itervalues(mm))
 
-        self.assertEqual(sorted(mm.items(), key=lambda k: k[0]),
+        self.assertEqual(sorted(six.iteritems(mm), key=lambda k: k[0]),
                           [('key1', 'value1'), ('key2', 'value3'),
                            ('key4', 'value6')])
 
@@ -185,10 +206,10 @@ class MultiValueDictTests(SimpleTestCase):
         self.assertEqual(d['name'], 'Simon')
         self.assertEqual(d.get('name'), 'Simon')
         self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
-        self.assertEqual(list(d.iteritems()),
+        self.assertEqual(list(six.iteritems(d)),
                           [('position', 'Developer'), ('name', 'Simon')])
 
-        self.assertEqual(list(d.iterlists()),
+        self.assertEqual(list(six.iterlists(d)),
                           [('position', ['Developer']),
                            ('name', ['Adrian', 'Simon'])])
 
@@ -208,8 +229,7 @@ class MultiValueDictTests(SimpleTestCase):
 
         d.setlist('lastname', ['Holovaty', 'Willison'])
         self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
-        self.assertEqual(d.values(), ['Developer', 'Simon', 'Willison'])
-        self.assertEqual(list(d.itervalues()),
+        self.assertEqual(list(six.itervalues(d)),
                           ['Developer', 'Simon', 'Willison'])
 
     def test_appendlist(self):
@@ -244,27 +264,13 @@ class MultiValueDictTests(SimpleTestCase):
             'pm': ['Rory'],
         })
         d = mvd.dict()
-        self.assertEqual(d.keys(), mvd.keys())
-        for key in mvd.keys():
+        self.assertEqual(list(six.iterkeys(d)), list(six.iterkeys(mvd)))
+        for key in six.iterkeys(mvd):
             self.assertEqual(d[key], mvd[key])
 
         self.assertEqual({}, MultiValueDict().dict())
 
 
-class DotExpandedDictTests(SimpleTestCase):
-
-    def test_dotexpandeddict(self):
-
-        d = DotExpandedDict({'person.1.firstname': ['Simon'],
-                             'person.1.lastname': ['Willison'],
-                             'person.2.firstname': ['Adrian'],
-                             'person.2.lastname': ['Holovaty']})
-
-        self.assertEqual(d['person']['1']['lastname'], ['Willison'])
-        self.assertEqual(d['person']['2']['lastname'], ['Holovaty'])
-        self.assertEqual(d['person']['2']['firstname'], ['Adrian'])
-
-
 class ImmutableListTests(SimpleTestCase):
 
     def test_sort(self):
diff --git a/tests/regressiontests/utils/html.py b/tests/regressiontests/utils/html.py
index 434873b9e0..fe40d4eaae 100644
--- a/tests/regressiontests/utils/html.py
+++ b/tests/regressiontests/utils/html.py
@@ -34,6 +34,17 @@ class TestUtilsHtml(unittest.TestCase):
         # Verify it doesn't double replace &.
         self.check_output(f, '<&', '&lt;&amp;')
 
+    def test_format_html(self):
+        self.assertEqual(
+            html.format_html("{0} {1} {third} {fourth}",
+                             "< Dangerous >",
+                             html.mark_safe("<b>safe</b>"),
+                             third="< dangerous again",
+                             fourth=html.mark_safe("<i>safe again</i>")
+                             ),
+            "&lt; Dangerous &gt; <b>safe</b> &lt; dangerous again <i>safe again</i>"
+            )
+
     def test_linebreaks(self):
         f = html.linebreaks
         items = (
diff --git a/tests/regressiontests/utils/simplelazyobject.py b/tests/regressiontests/utils/simplelazyobject.py
index 982d2226e6..960a5e3201 100644
--- a/tests/regressiontests/utils/simplelazyobject.py
+++ b/tests/regressiontests/utils/simplelazyobject.py
@@ -4,6 +4,7 @@ import copy
 import pickle
 
 from django.test.utils import str_prefix
+from django.utils import six
 from django.utils.unittest import TestCase
 from django.utils.functional import SimpleLazyObject, empty
 
@@ -22,7 +23,7 @@ class _ComplexObject(object):
         return "I am _ComplexObject(%r)" % self.name
 
     def __unicode__(self):
-        return unicode(self.name)
+        return six.text_type(self.name)
 
     def __repr__(self):
         return "_ComplexObject(%r)" % self.name
@@ -58,7 +59,7 @@ class TestUtilsSimpleLazyObject(TestCase):
             str(SimpleLazyObject(complex_object)))
 
     def test_unicode(self):
-        self.assertEqual("joe", unicode(SimpleLazyObject(complex_object)))
+        self.assertEqual("joe", six.text_type(SimpleLazyObject(complex_object)))
 
     def test_class(self):
         # This is important for classes that use __class__ in things like
@@ -108,5 +109,5 @@ class TestUtilsSimpleLazyObject(TestCase):
         pickled = pickle.dumps(x)
         unpickled = pickle.loads(pickled)
         self.assertEqual(unpickled, x)
-        self.assertEqual(unicode(unpickled), unicode(x))
+        self.assertEqual(six.text_type(unpickled), six.text_type(x))
         self.assertEqual(unpickled.name, x.name)
diff --git a/tests/regressiontests/utils/tests.py b/tests/regressiontests/utils/tests.py
index f5ca06ef1e..a7deeeefae 100644
--- a/tests/regressiontests/utils/tests.py
+++ b/tests/regressiontests/utils/tests.py
@@ -16,7 +16,7 @@ from .decorators import DecoratorFromMiddlewareTests
 from .functional import FunctionalTestCase
 from .timesince import TimesinceTests
 from .datastructures import (MultiValueDictTests, SortedDictTests,
-    DictWrapperTests, ImmutableListTests, DotExpandedDictTests, MergeDictTests)
+    DictWrapperTests, ImmutableListTests, MergeDictTests)
 from .tzinfo import TzinfoTests
 from .datetime_safe import DatetimeTests
 from .baseconv import TestBaseConv