fix poor assert's in tests

tests/document/inheritance.py

@@ -38,12 +38,12 @@ class InheritanceTest(unittest.TestCase):
             meta = {'allow_inheritance': True}
 
         test_doc = DataDoc(name='test', embed=EmbedData(data='data'))
-        assert test_doc._cls == 'DataDoc'
+        self.assertEqual(test_doc._cls, 'DataDoc')
-        assert test_doc.embed._cls == 'EmbedData'
+        self.assertEqual(test_doc.embed._cls, 'EmbedData')
         test_doc.save()
         saved_doc = DataDoc.objects.with_id(test_doc.id)
-        assert test_doc._cls == saved_doc._cls
+        self.assertEqual(test_doc._cls, saved_doc._cls)
-        assert test_doc.embed._cls == saved_doc.embed._cls
+        self.assertEqual(test_doc.embed._cls, saved_doc.embed._cls)
         test_doc.delete()
 
     def test_superclasses(self):

tests/document/instance.py

@@ -806,7 +806,8 @@ class InstanceTest(MongoDBTestCase):
         doc2 = self.Person(name="jim", age=20).save()
         docs = [dict(doc1.to_mongo()), dict(doc2.to_mongo())]
 
-        assert not doc1.modify({'name': doc2.name}, set__age=100)
+        n_modified = doc1.modify({'name': doc2.name}, set__age=100)
+        self.assertEqual(n_modified, 0)
 
         self.assertDbEqual(docs)
 
@@ -815,7 +816,8 @@ class InstanceTest(MongoDBTestCase):
         doc2 = self.Person(id=ObjectId(), name="jim", age=20)
         docs = [dict(doc1.to_mongo())]
 
-        assert not doc2.modify({'name': doc2.name}, set__age=100)
+        n_modified = doc2.modify({'name': doc2.name}, set__age=100)
+        self.assertEqual(n_modified, 0)
 
         self.assertDbEqual(docs)
 
@@ -831,14 +833,15 @@ class InstanceTest(MongoDBTestCase):
         doc.job.name = "Google"
         doc.job.years = 3
 
-        assert doc.modify(
+        n_modified = doc.modify(
             set__age=21, set__job__name="MongoDB", unset__job__years=True)
+        self.assertEqual(n_modified, 1)
         doc_copy.age = 21
         doc_copy.job.name = "MongoDB"
         del doc_copy.job.years
 
-        assert doc.to_json() == doc_copy.to_json()
+        self.assertEqual(doc.to_json(), doc_copy.to_json())
-        assert doc._get_changed_fields() == []
+        self.assertEqual(doc._get_changed_fields(), [])
 
         self.assertDbEqual([dict(other_doc.to_mongo()), dict(doc.to_mongo())])
 

tests/fields/fields.py

@@ -2168,15 +2168,15 @@ class FieldTest(MongoDBTestCase):
         to_embed = ToEmbed(id=2, recursive=to_embed_recursive).save()
         doc = Doc(field=to_embed)
         doc.save()
-        assert isinstance(doc.field, ToEmbed)
+        self.assertIsInstance(doc.field, ToEmbed)
-        assert doc.field == to_embed
+        self.assertEqual(doc.field, to_embed)
         # Same thing with a Document with a _cls field
         to_embed_recursive = ToEmbedChild(id=1).save()
         to_embed_child = ToEmbedChild(id=2, recursive=to_embed_recursive).save()
         doc = Doc(field=to_embed_child)
         doc.save()
-        assert isinstance(doc.field, ToEmbedChild)
+        self.assertIsInstance(doc.field, ToEmbedChild)
-        assert doc.field == to_embed_child
+        self.assertEqual(doc.field, to_embed_child)
 
     def test_cls_field(self):
         class Animal(Document):

tests/fields/test_dict_field.py

@@ -116,19 +116,20 @@ class TestDictField(MongoDBTestCase):
             id=2, recursive=to_embed_recursive.to_mongo().to_dict()).save()
         doc = Doc(field=to_embed.to_mongo().to_dict())
         doc.save()
-        assert isinstance(doc.field, dict)
+        self.assertIsInstance(doc.field, dict)
-        assert doc.field == {'_id': 2, 'recursive': {'_id': 1, 'recursive': {}}}
+        self.assertEqual(doc.field, {'_id': 2, 'recursive': {'_id': 1, 'recursive': {}}})
         # Same thing with a Document with a _cls field
         to_embed_recursive = ToEmbedChild(id=1).save()
         to_embed_child = ToEmbedChild(
             id=2, recursive=to_embed_recursive.to_mongo().to_dict()).save()
         doc = Doc(field=to_embed_child.to_mongo().to_dict())
         doc.save()
-        assert isinstance(doc.field, dict)
+        self.assertIsInstance(doc.field, dict)
-        assert doc.field == {
+        expected = {
             '_id': 2, '_cls': 'ToEmbedParent.ToEmbedChild',
             'recursive': {'_id': 1, '_cls': 'ToEmbedParent.ToEmbedChild', 'recursive': {}}
         }
+        self.assertEqual(doc.field, expected)
 
     def test_dictfield_strict(self):
         """Ensure that dict field handles validation if provided a strict field type."""

tests/test_datastructures.py

@@ -203,7 +203,7 @@ class TestBaseList(unittest.TestCase):
 
     def test___getitem__using_slice(self):
         base_list = self._get_baselist([0, 1, 2])
-        self.assertEqual(base_list[1:3], [1,2])
+        self.assertEqual(base_list[1:3], [1, 2])
         self.assertEqual(base_list[0:3:2], [0, 2])
 
     def test___getitem___using_slice_returns_list(self):
@@ -218,7 +218,7 @@ class TestBaseList(unittest.TestCase):
     def test___getitem__sublist_returns_BaseList_bound_to_instance(self):
         base_list = self._get_baselist(
             [
-                [1,2],
+                [1, 2],
                 [3, 4]
             ]
         )
@@ -305,10 +305,10 @@ class TestBaseList(unittest.TestCase):
         self.assertEqual(base_list, [-1, 1, -2])
 
     def test___setitem___with_slice(self):
-        base_list = self._get_baselist([0,1,2,3,4,5])
+        base_list = self._get_baselist([0, 1, 2, 3, 4, 5])
         base_list[0:6:2] = [None, None, None]
         self.assertEqual(base_list._instance._changed_fields, ['my_name'])
-        self.assertEqual(base_list, [None,1,None,3,None,5])
+        self.assertEqual(base_list, [None, 1, None, 3, None, 5])
 
     def test___setitem___item_0_calls_mark_as_changed(self):
         base_list = self._get_baselist([True])
@@ -426,8 +426,8 @@ class TestStrictDict(unittest.TestCase):
 
     def test_mappings_protocol(self):
         d = self.dtype(a=1, b=2)
-        assert dict(d) == {'a': 1, 'b': 2}
+        self.assertEqual(dict(d), {'a': 1, 'b': 2})
-        assert dict(**d) == {'a': 1, 'b': 2}
+        self.assertEqual(dict(**d), {'a': 1, 'b': 2})
 
 
 if __name__ == '__main__':