Fixed E128 flake8 warnings in tests/.

3 files changed, 36 insertions, 41 deletions

diff --git a/tests/serializers/test_data.py b/tests/serializers/test_data.py
index 560006759f..4318856307 100644
--- a/tests/serializers/test_data.py
+++ b/tests/serializers/test_data.py
@@ -120,15 +120,19 @@ def inherited_create(pk, klass, data):
 def data_compare(testcase, pk, klass, data):
     instance = klass.objects.get(id=pk)
     if klass == BinaryData and data is not None:
-        testcase.assertEqual(bytes(data), bytes(instance.data),
-             "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
-                 pk, repr(bytes(data)), type(data), repr(bytes(instance.data)),
-                 type(instance.data))
+        testcase.assertEqual(
+            bytes(data), bytes(instance.data),
+            "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
+                pk, repr(bytes(data)), type(data), repr(bytes(instance.data)),
+                type(instance.data),
+            )
         )
     else:
-        testcase.assertEqual(data, instance.data,
-             "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
-                 pk, data, type(data), instance, type(instance.data))
+        testcase.assertEqual(
+            data, instance.data,
+            "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
+                pk, data, type(data), instance, type(instance.data),
+            )
         )
 
 
diff --git a/tests/serializers/test_natural.py b/tests/serializers/test_natural.py
index 6682e5cdd8..8f4d00d5a6 100644
--- a/tests/serializers/test_natural.py
+++ b/tests/serializers/test_natural.py
@@ -21,8 +21,7 @@ def natural_key_serializer_test(format, self):
             FKDataNaturalKey.objects.create(id=1102, data_id=None),
         ]
     # Serialize the test database
-    serialized_data = serializers.serialize(format, objects, indent=2,
-        use_natural_foreign_keys=True)
+    serialized_data = serializers.serialize(format, objects, indent=2, use_natural_foreign_keys=True)
 
     for obj in serializers.deserialize(format, serialized_data):
         obj.save()
@@ -31,15 +30,19 @@ def natural_key_serializer_test(format, self):
     # as the original source
     for obj in objects:
         instance = obj.__class__.objects.get(id=obj.pk)
-        self.assertEqual(obj.data, instance.data,
-             "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
-                 obj.pk, obj.data, type(obj.data), instance, type(instance.data))
+        self.assertEqual(
+            obj.data, instance.data,
+            "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
+                obj.pk, obj.data, type(obj.data), instance, type(instance.data),
+            )
         )
 
 
 def natural_key_test(format, self):
-    book1 = {'data': '978-1590597255', 'title': 'The Definitive Guide to '
-             'Django: Web Development Done Right'}
+    book1 = {
+        'data': '978-1590597255',
+        'title': 'The Definitive Guide to Django: Web Development Done Right',
+    }
     book2 = {'data': '978-1590599969', 'title': 'Practical Django Projects'}
 
     # Create the books.
@@ -47,9 +50,10 @@ def natural_key_test(format, self):
     james = NaturalKeyAnchor.objects.create(**book2)
 
     # Serialize the books.
-    string_data = serializers.serialize(format, NaturalKeyAnchor.objects.all(),
-                                        indent=2, use_natural_foreign_keys=True,
-                                        use_natural_primary_keys=True)
+    string_data = serializers.serialize(
+        format, NaturalKeyAnchor.objects.all(), indent=2,
+        use_natural_foreign_keys=True, use_natural_primary_keys=True,
+    )
 
     # Delete one book (to prove that the natural key generation will only
     # restore the primary keys of books found in the database via the
diff --git a/tests/serializers/tests.py b/tests/serializers/tests.py
index c18cdae7e0..96284ca642 100644
--- a/tests/serializers/tests.py
+++ b/tests/serializers/tests.py
@@ -124,14 +124,12 @@ class SerializersTestBase(object):
 
     def test_serialize(self):
         """Tests that basic serialization works."""
-        serial_str = serializers.serialize(self.serializer_name,
-                                           Article.objects.all())
+        serial_str = serializers.serialize(self.serializer_name, Article.objects.all())
         self.assertTrue(self._validate_output(serial_str))
 
     def test_serializer_roundtrip(self):
         """Tests that serialized content can be deserialized."""
-        serial_str = serializers.serialize(self.serializer_name,
-                                           Article.objects.all())
+        serial_str = serializers.serialize(self.serializer_name, Article.objects.all())
         models = list(serializers.deserialize(self.serializer_name, serial_str))
         self.assertEqual(len(models), 2)
 
@@ -174,8 +172,7 @@ class SerializersTestBase(object):
         """
         old_headline = "Poker has no place on ESPN"
         new_headline = "Poker has no place on television"
-        serial_str = serializers.serialize(self.serializer_name,
-                                           Article.objects.all())
+        serial_str = serializers.serialize(self.serializer_name, Article.objects.all())
         serial_str = serial_str.replace(old_headline, new_headline)
         models = list(serializers.deserialize(self.serializer_name, serial_str))
 
@@ -196,11 +193,8 @@ class SerializersTestBase(object):
         (such as a OneToOneField), it doesn't appear in the
         serialized field list - it replaces the pk identifier.
         """
-        profile = AuthorProfile(author=self.joe,
-                                date_of_birth=datetime(1970, 1, 1))
-        profile.save()
-        serial_str = serializers.serialize(self.serializer_name,
-                                           AuthorProfile.objects.all())
+        AuthorProfile.objects.create(author=self.joe, date_of_birth=datetime(1970, 1, 1))
+        serial_str = serializers.serialize(self.serializer_name, AuthorProfile.objects.all())
         self.assertFalse(self._get_field_values(serial_str, 'author'))
 
         for obj in serializers.deserialize(self.serializer_name, serial_str):
@@ -210,9 +204,7 @@ class SerializersTestBase(object):
         """Tests that output can be restricted to a subset of fields"""
         valid_fields = ('headline', 'pub_date')
         invalid_fields = ("author", "categories")
-        serial_str = serializers.serialize(self.serializer_name,
-                                    Article.objects.all(),
-                                    fields=valid_fields)
+        serial_str = serializers.serialize(self.serializer_name, Article.objects.all(), fields=valid_fields)
         for field_name in invalid_fields:
             self.assertFalse(self._get_field_values(serial_str, field_name))
 
@@ -269,8 +261,7 @@ class SerializersTestBase(object):
         pk_value = self._get_pk_values(serial_str)[0]
         self.assertFalse(pk_value)
 
-        cat_obj = list(serializers.deserialize(self.serializer_name,
-                                               serial_str))[0].object
+        cat_obj = list(serializers.deserialize(self.serializer_name, serial_str))[0].object
         self.assertEqual(cat_obj.id, None)
 
     def test_float_serialization(self):
@@ -278,8 +269,7 @@ class SerializersTestBase(object):
         sc = Score(score=3.4)
         sc.save()
         serial_str = serializers.serialize(self.serializer_name, [sc])
-        deserial_objs = list(serializers.deserialize(self.serializer_name,
-                                                serial_str))
+        deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str))
         self.assertEqual(deserial_objs[0].object.score, Approximate(3.4, places=1))
 
     def test_deferred_field_serialization(self):
@@ -299,15 +289,13 @@ class SerializersTestBase(object):
         player.rank = 1
         player.team = Team(team_str)
         player.save()
-        serial_str = serializers.serialize(self.serializer_name,
-                                           Player.objects.all())
+        serial_str = serializers.serialize(self.serializer_name, Player.objects.all())
         team = self._get_field_values(serial_str, "team")
         self.assertTrue(team)
         self.assertEqual(team[0], team_str)
 
         deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str))
-        self.assertEqual(deserial_objs[0].object.team.to_string(),
-                         player.team.to_string())
+        self.assertEqual(deserial_objs[0].object.team.to_string(), player.team.to_string())
 
     def test_pre_1000ad_date(self):
         """Tests that year values before 1000AD are properly formatted"""
@@ -327,8 +315,7 @@ class SerializersTestBase(object):
         Tests that serialized strings without PKs
         can be turned into models
         """
-        deserial_objs = list(serializers.deserialize(self.serializer_name,
-                                                     self.pkless_str))
+        deserial_objs = list(serializers.deserialize(self.serializer_name, self.pkless_str))
         for obj in deserial_objs:
             self.assertFalse(obj.object.id)
             obj.save()