Replace assert_equal with assertEqual

Also change TestActor to subclass TestBase rather than object and create and use base TestCommitSerialization class for assert_commit_serialization method

Author: Harmon758

git/test/lib/asserts.py

@@ -7,13 +7,12 @@
 from unittest.mock import patch
 
 from nose.tools import (
-    assert_equal,       # @UnusedImport
     assert_not_equal,   # @UnusedImport
     assert_raises,      # @UnusedImport
     raises,             # @UnusedImport
     assert_true,        # @UnusedImport
     assert_false        # @UnusedImport
 )
 
-__all__ = ['assert_equal', 'assert_not_equal', 'assert_raises', 'patch', 'raises',
+__all__ = ['assert_not_equal', 'assert_raises', 'patch', 'raises',
            'assert_true', 'assert_false']

git/test/performance/test_commit.py

@@ -11,10 +11,10 @@
 from .lib import TestBigRepoRW
 from git import Commit
 from gitdb import IStream
-from git.test.test_commit import assert_commit_serialization
+from git.test.test_commit import TestCommitSerialization
 
 
-class TestPerformance(TestBigRepoRW):
+class TestPerformance(TestBigRepoRW, TestCommitSerialization):
 
     def tearDown(self):
         import gc
@@ -79,7 +79,7 @@ def test_commit_iteration(self):
               % (nc, elapsed_time, nc / elapsed_time), file=sys.stderr)
 
     def test_commit_serialization(self):
-        assert_commit_serialization(self.gitrwrepo, '58c78e6', True)
+        self.assert_commit_serialization(self.gitrwrepo, '58c78e6', True)
 
         rwrepo = self.gitrwrepo
         make_object = rwrepo.odb.store

git/test/test_actor.py

@@ -4,16 +4,16 @@
 # This module is part of GitPython and is released under
 # the BSD License: http://www.opensource.org/licenses/bsd-license.php
 
-from git.test.lib import assert_equal
+from git.test.lib import TestBase
 from git import Actor
 
 
-class TestActor(object):
+class TestActor(TestBase):
 
     def test_from_string_should_separate_name_and_email(self):
         a = Actor._from_string("Michael Trier <mtrier@example.com>")
-        assert_equal("Michael Trier", a.name)
-        assert_equal("mtrier@example.com", a.email)
+        self.assertEqual("Michael Trier", a.name)
+        self.assertEqual("mtrier@example.com", a.email)
 
         # base type capabilities
         assert a == a
@@ -25,13 +25,13 @@ def test_from_string_should_separate_name_and_email(self):
 
     def test_from_string_should_handle_just_name(self):
         a = Actor._from_string("Michael Trier")
-        assert_equal("Michael Trier", a.name)
-        assert_equal(None, a.email)
+        self.assertEqual("Michael Trier", a.name)
+        self.assertEqual(None, a.email)
 
     def test_should_display_representation(self):
         a = Actor._from_string("Michael Trier <mtrier@example.com>")
-        assert_equal('<git.Actor "Michael Trier <mtrier@example.com>">', repr(a))
+        self.assertEqual('<git.Actor "Michael Trier <mtrier@example.com>">', repr(a))
 
     def test_str_should_alias_name(self):
         a = Actor._from_string("Michael Trier <mtrier@example.com>")
-        assert_equal(a.name, str(a))
+        self.assertEqual(a.name, str(a))

git/test/test_blob.py

@@ -4,22 +4,19 @@
 # This module is part of GitPython and is released under
 # the BSD License: http://www.opensource.org/licenses/bsd-license.php
 
-from git.test.lib import (
-    TestBase,
-    assert_equal
-)
+from git.test.lib import TestBase
 from git import Blob
 
 
 class TestBlob(TestBase):
 
     def test_mime_type_should_return_mime_type_for_known_types(self):
         blob = Blob(self.rorepo, **{'binsha': Blob.NULL_BIN_SHA, 'path': 'foo.png'})
-        assert_equal("image/png", blob.mime_type)
+        self.assertEqual("image/png", blob.mime_type)
 
     def test_mime_type_should_return_text_plain_for_unknown_types(self):
         blob = Blob(self.rorepo, **{'binsha': Blob.NULL_BIN_SHA, 'path': 'something'})
-        assert_equal("text/plain", blob.mime_type)
+        self.assertEqual("text/plain", blob.mime_type)
 
     def test_nodict(self):
         self.assertRaises(AttributeError, setattr, self.rorepo.tree()['AUTHORS'], 'someattr', 2)

git/test/test_commit.py

@@ -22,7 +22,6 @@
 from git.repo.fun import touch
 from git.test.lib import (
     TestBase,
-    assert_equal,
     assert_not_equal,
     with_rw_repo,
     fixture_path,
@@ -34,58 +33,60 @@
 import os.path as osp
 
 
-def assert_commit_serialization(rwrepo, commit_id, print_performance_info=False):
-    """traverse all commits in the history of commit identified by commit_id and check
-    if the serialization works.
-    :param print_performance_info: if True, we will show how fast we are"""
-    ns = 0      # num serializations
-    nds = 0     # num deserializations
+class TestCommitSerialization(TestBase):
 
-    st = time.time()
-    for cm in rwrepo.commit(commit_id).traverse():
-        nds += 1
+    def assert_commit_serialization(self, rwrepo, commit_id, print_performance_info=False):
+        """traverse all commits in the history of commit identified by commit_id and check
+        if the serialization works.
+        :param print_performance_info: if True, we will show how fast we are"""
+        ns = 0      # num serializations
+        nds = 0     # num deserializations
 
-        # assert that we deserialize commits correctly, hence we get the same
-        # sha on serialization
-        stream = BytesIO()
-        cm._serialize(stream)
-        ns += 1
-        streamlen = stream.tell()
-        stream.seek(0)
+        st = time.time()
+        for cm in rwrepo.commit(commit_id).traverse():
+            nds += 1
 
-        istream = rwrepo.odb.store(IStream(Commit.type, streamlen, stream))
-        assert_equal(istream.hexsha, cm.hexsha.encode('ascii'))
+            # assert that we deserialize commits correctly, hence we get the same
+            # sha on serialization
+            stream = BytesIO()
+            cm._serialize(stream)
+            ns += 1
+            streamlen = stream.tell()
+            stream.seek(0)
 
-        nc = Commit(rwrepo, Commit.NULL_BIN_SHA, cm.tree,
-                    cm.author, cm.authored_date, cm.author_tz_offset,
-                    cm.committer, cm.committed_date, cm.committer_tz_offset,
-                    cm.message, cm.parents, cm.encoding)
+            istream = rwrepo.odb.store(IStream(Commit.type, streamlen, stream))
+            self.assertEqual(istream.hexsha, cm.hexsha.encode('ascii'))
 
-        assert_equal(nc.parents, cm.parents)
-        stream = BytesIO()
-        nc._serialize(stream)
-        ns += 1
-        streamlen = stream.tell()
-        stream.seek(0)
+            nc = Commit(rwrepo, Commit.NULL_BIN_SHA, cm.tree,
+                        cm.author, cm.authored_date, cm.author_tz_offset,
+                        cm.committer, cm.committed_date, cm.committer_tz_offset,
+                        cm.message, cm.parents, cm.encoding)
 
-        # reuse istream
-        istream.size = streamlen
-        istream.stream = stream
-        istream.binsha = None
-        nc.binsha = rwrepo.odb.store(istream).binsha
+            self.assertEqual(nc.parents, cm.parents)
+            stream = BytesIO()
+            nc._serialize(stream)
+            ns += 1
+            streamlen = stream.tell()
+            stream.seek(0)
 
-        # if it worked, we have exactly the same contents !
-        assert_equal(nc.hexsha, cm.hexsha)
-    # END check commits
-    elapsed = time.time() - st
+            # reuse istream
+            istream.size = streamlen
+            istream.stream = stream
+            istream.binsha = None
+            nc.binsha = rwrepo.odb.store(istream).binsha
 
-    if print_performance_info:
-        print("Serialized %i and deserialized %i commits in %f s ( (%f, %f) commits / s"
-              % (ns, nds, elapsed, ns / elapsed, nds / elapsed), file=sys.stderr)
-    # END handle performance info
+            # if it worked, we have exactly the same contents !
+            self.assertEqual(nc.hexsha, cm.hexsha)
+        # END check commits
+        elapsed = time.time() - st
 
+        if print_performance_info:
+            print("Serialized %i and deserialized %i commits in %f s ( (%f, %f) commits / s"
+                  % (ns, nds, elapsed, ns / elapsed, nds / elapsed), file=sys.stderr)
+        # END handle performance info
 
-class TestCommit(TestBase):
+
+class TestCommit(TestCommitSerialization):
 
     def test_bake(self):
 
@@ -94,8 +95,8 @@ def test_bake(self):
         self.assertRaises(AttributeError, setattr, commit, 'someattr', 1)
         commit.author  # bake
 
-        assert_equal("Sebastian Thiel", commit.author.name)
-        assert_equal("byronimo@gmail.com", commit.author.email)
+        self.assertEqual("Sebastian Thiel", commit.author.name)
+        self.assertEqual("byronimo@gmail.com", commit.author.email)
         self.assertEqual(commit.author, commit.committer)
         assert isinstance(commit.authored_date, int) and isinstance(commit.committed_date, int)
         assert isinstance(commit.author_tz_offset, int) and isinstance(commit.committer_tz_offset, int)
@@ -220,7 +221,7 @@ def test_rev_list_bisect_all(self):
             '933d23bf95a5bd1624fbcdf328d904e1fa173474'
         )
         for sha1, commit in zip(expected_ids, commits):
-            assert_equal(sha1, commit.hexsha)
+            self.assertEqual(sha1, commit.hexsha)
 
     @with_rw_directory
     def test_ambiguous_arg_iteration(self, rw_dir):
@@ -242,17 +243,17 @@ def test_list(self):
 
     def test_str(self):
         commit = Commit(self.rorepo, Commit.NULL_BIN_SHA)
-        assert_equal(Commit.NULL_HEX_SHA, str(commit))
+        self.assertEqual(Commit.NULL_HEX_SHA, str(commit))
 
     def test_repr(self):
         commit = Commit(self.rorepo, Commit.NULL_BIN_SHA)
-        assert_equal('<git.Commit "%s">' % Commit.NULL_HEX_SHA, repr(commit))
+        self.assertEqual('<git.Commit "%s">' % Commit.NULL_HEX_SHA, repr(commit))
 
     def test_equality(self):
         commit1 = Commit(self.rorepo, Commit.NULL_BIN_SHA)
         commit2 = Commit(self.rorepo, Commit.NULL_BIN_SHA)
         commit3 = Commit(self.rorepo, "\1" * 20)
-        assert_equal(commit1, commit2)
+        self.assertEqual(commit1, commit2)
         assert_not_equal(commit2, commit3)
 
     def test_iter_parents(self):
@@ -272,7 +273,7 @@ def test_name_rev(self):
     @with_rw_repo('HEAD', bare=True)
     def test_serialization(self, rwrepo):
         # create all commits of our repo
-        assert_commit_serialization(rwrepo, '0.1.6')
+        self.assert_commit_serialization(rwrepo, '0.1.6')
 
     def test_serialization_unicode_support(self):
         self.assertEqual(Commit.default_encoding.lower(), 'utf-8')

git/test/test_diff.py

@@ -20,7 +20,6 @@
     TestBase,
     StringProcessAdapter,
     fixture,
-    assert_equal,
     assert_true,
 )
 from git.test.lib import with_rw_directory
@@ -95,23 +94,23 @@ def test_list_from_string_new_mode(self):
         diffs = Diff._index_from_patch_format(self.rorepo, output)
         self._assert_diff_format(diffs)
 
-        assert_equal(1, len(diffs))
-        assert_equal(8, len(diffs[0].diff.splitlines()))
+        self.assertEqual(1, len(diffs))
+        self.assertEqual(8, len(diffs[0].diff.splitlines()))
 
     def test_diff_with_rename(self):
         output = StringProcessAdapter(fixture('diff_rename'))
         diffs = Diff._index_from_patch_format(self.rorepo, output)
         self._assert_diff_format(diffs)
 
-        assert_equal(1, len(diffs))
+        self.assertEqual(1, len(diffs))
 
         diff = diffs[0]
         assert_true(diff.renamed_file)
         assert_true(diff.renamed)
-        assert_equal(diff.rename_from, u'Jérôme')
-        assert_equal(diff.rename_to, u'müller')
-        assert_equal(diff.raw_rename_from, b'J\xc3\xa9r\xc3\xb4me')
-        assert_equal(diff.raw_rename_to, b'm\xc3\xbcller')
+        self.assertEqual(diff.rename_from, u'Jérôme')
+        self.assertEqual(diff.rename_to, u'müller')
+        self.assertEqual(diff.raw_rename_from, b'J\xc3\xa9r\xc3\xb4me')
+        self.assertEqual(diff.raw_rename_to, b'm\xc3\xbcller')
         assert isinstance(str(diff), str)
 
         output = StringProcessAdapter(fixture('diff_rename_raw'))
@@ -131,7 +130,7 @@ def test_diff_with_copied_file(self):
         diffs = Diff._index_from_patch_format(self.rorepo, output)
         self._assert_diff_format(diffs)
 
-        assert_equal(1, len(diffs))
+        self.assertEqual(1, len(diffs))
 
         diff = diffs[0]
         assert_true(diff.copied_file)
@@ -153,17 +152,17 @@ def test_diff_with_change_in_type(self):
         output = StringProcessAdapter(fixture('diff_change_in_type'))
         diffs = Diff._index_from_patch_format(self.rorepo, output)
         self._assert_diff_format(diffs)
-        assert_equal(2, len(diffs))
+        self.assertEqual(2, len(diffs))
 
         diff = diffs[0]
         self.assertIsNotNone(diff.deleted_file)
-        assert_equal(diff.a_path, 'this')
-        assert_equal(diff.b_path, 'this')
+        self.assertEqual(diff.a_path, 'this')
+        self.assertEqual(diff.b_path, 'this')
         assert isinstance(str(diff), str)
 
         diff = diffs[1]
-        assert_equal(diff.a_path, None)
-        assert_equal(diff.b_path, 'this')
+        self.assertEqual(diff.a_path, None)
+        self.assertEqual(diff.b_path, 'this')
         self.assertIsNotNone(diff.new_file)
         assert isinstance(str(diff), str)