tests: convert tests_hg.py to py.test

kallithea/tests/vcs/test_hg.py

@@ -9,10 +9,9 b' from kallithea.lib.vcs.nodes import Node'
 
 from kallithea.tests.vcs.conf import TEST_HG_REPO, TEST_HG_REPO_CLONE, \
     TEST_HG_REPO_PULL, TESTS_TMP_PATH
-from kallithea.lib.vcs.utils.compat import unittest
 
 
-class MercurialRepositoryTest(unittest.TestCase):
+class TestMercurialRepository(object):
 
     def __check_for_existing_repo(self):
         if os.path.exists(TEST_HG_REPO_CLONE):
@@ -20,46 +19,52 b' class MercurialRepositoryTest(unittest.T'
                       'exists. You should manually remove it first.'
                       % TEST_HG_REPO_CLONE)
 
-    def setUp(self):
+    def setup_method(self):
         self.repo = MercurialRepository(safe_str(TEST_HG_REPO))
 
     def test_wrong_repo_path(self):
         wrong_repo_path = os.path.join(TESTS_TMP_PATH, 'errorrepo')
-        self.assertRaises(RepositoryError, MercurialRepository, wrong_repo_path)
+        with pytest.raises(RepositoryError):
+            MercurialRepository(wrong_repo_path)
 
     def test_unicode_path_repo(self):
-        self.assertRaises(VCSError, lambda: MercurialRepository(u'iShouldFail'))
+        with pytest.raises(VCSError):
+            MercurialRepository(u'iShouldFail')
 
     def test_repo_clone(self):
         self.__check_for_existing_repo()
         repo = MercurialRepository(safe_str(TEST_HG_REPO))
         repo_clone = MercurialRepository(TEST_HG_REPO_CLONE,
             src_url=TEST_HG_REPO, update_after_clone=True)
-        self.assertEqual(len(repo.revisions), len(repo_clone.revisions))
+        assert len(repo.revisions) == len(repo_clone.revisions)
         # Checking hashes of changesets should be enough
         for changeset in repo.get_changesets():
             raw_id = changeset.raw_id
-            self.assertEqual(raw_id, repo_clone.get_changeset(raw_id).raw_id)
+            assert raw_id == repo_clone.get_changeset(raw_id).raw_id
 
     def test_repo_clone_with_update(self):
         repo = MercurialRepository(safe_str(TEST_HG_REPO))
         repo_clone = MercurialRepository(TEST_HG_REPO_CLONE + '_w_update',
             src_url=TEST_HG_REPO, update_after_clone=True)
-        self.assertEqual(len(repo.revisions), len(repo_clone.revisions))
+        assert len(repo.revisions) == len(repo_clone.revisions)
 
         # check if current workdir was updated
-        self.assertEqual(os.path.isfile(os.path.join(TEST_HG_REPO_CLONE \
-                                                    + '_w_update',
-                                                    'MANIFEST.in')), True,)
+        assert os.path.isfile(
+            os.path.join(
+                TEST_HG_REPO_CLONE + '_w_update', 'MANIFEST.in'
+            )
+        )
 
     def test_repo_clone_without_update(self):
         repo = MercurialRepository(safe_str(TEST_HG_REPO))
         repo_clone = MercurialRepository(TEST_HG_REPO_CLONE + '_wo_update',
             src_url=TEST_HG_REPO, update_after_clone=False)
-        self.assertEqual(len(repo.revisions), len(repo_clone.revisions))
-        self.assertEqual(os.path.isfile(os.path.join(TEST_HG_REPO_CLONE \
-                                                    + '_wo_update',
-                                                    'MANIFEST.in')), False,)
+        assert len(repo.revisions) == len(repo_clone.revisions)
+        assert not os.path.isfile(
+            os.path.join(
+                TEST_HG_REPO_CLONE + '_wo_update', 'MANIFEST.in'
+            )
+        )
 
     def test_pull(self):
         if os.path.exists(TEST_HG_REPO_PULL):
@@ -67,11 +72,11 b' class MercurialRepositoryTest(unittest.T'
                       'already exists. You should manually remove it first'
                       % TEST_HG_REPO_PULL)
         repo_new = MercurialRepository(TEST_HG_REPO_PULL, create=True)
-        self.assertTrue(len(self.repo.revisions) > len(repo_new.revisions))
+        assert len(self.repo.revisions) > len(repo_new.revisions)
 
         repo_new.pull(self.repo.path)
         repo_new = MercurialRepository(TEST_HG_REPO_PULL)
-        self.assertTrue(len(self.repo.revisions) == len(repo_new.revisions))
+        assert len(self.repo.revisions) == len(repo_new.revisions)
 
     def test_revisions(self):
         # there are 21 revisions at bitbucket now
@@ -96,7 +101,7 b' class MercurialRepositoryTest(unittest.T'
                  'aa6a0de05b7612707db567078e130a6cd114a9a7',
                  'eada5a770da98ab0dd7325e29d00e0714f228d09'
                 ])
-        self.assertTrue(subset.issubset(set(self.repo.revisions)))
+        assert subset.issubset(set(self.repo.revisions))
 
         # check if we have the proper order of revisions
         org = ['b986218ba1c9b0d6a259fac9b050b1724ed8e545',
@@ -130,90 +135,87 b' class MercurialRepositoryTest(unittest.T'
                 'ff5ab059786ebc7411e559a2cc309dfae3625a3b',
                 '6b6ad5f82ad5bb6190037671bd254bd4e1f4bf08',
                 'ee87846a61c12153b51543bf860e1026c6d3dcba', ]
-        self.assertEqual(org, self.repo.revisions[:31])
+        assert org == self.repo.revisions[:31]
 
     def test_iter_slice(self):
         sliced = list(self.repo[:10])
         itered = list(self.repo)[:10]
-        self.assertEqual(sliced, itered)
+        assert sliced == itered
 
     def test_slicing(self):
         # 4 1 5 10 95
         for sfrom, sto, size in [(0, 4, 4), (1, 2, 1), (10, 15, 5),
                                  (10, 20, 10), (5, 100, 95)]:
             revs = list(self.repo[sfrom:sto])
-            self.assertEqual(len(revs), size)
-            self.assertEqual(revs[0], self.repo.get_changeset(sfrom))
-            self.assertEqual(revs[-1], self.repo.get_changeset(sto - 1))
+            assert len(revs) == size
+            assert revs[0] == self.repo.get_changeset(sfrom)
+            assert revs[-1] == self.repo.get_changeset(sto - 1)
 
     def test_branches(self):
         # TODO: Need more tests here
 
         # active branches
-        self.assertTrue('default' in self.repo.branches)
-        self.assertTrue('stable' in self.repo.branches)
+        assert 'default' in self.repo.branches
+        assert 'stable' in self.repo.branches
 
         # closed
-        self.assertTrue('git' in self.repo._get_branches(closed=True))
-        self.assertTrue('web' in self.repo._get_branches(closed=True))
+        assert 'git' in self.repo._get_branches(closed=True)
+        assert 'web' in self.repo._get_branches(closed=True)
 
         for name, id in self.repo.branches.items():
-            self.assertTrue(isinstance(
-                self.repo.get_changeset(id), MercurialChangeset))
+            assert isinstance(self.repo.get_changeset(id), MercurialChangeset)
 
     def test_tip_in_tags(self):
         # tip is always a tag
-        self.assertIn('tip', self.repo.tags)
+        assert 'tip' in self.repo.tags
 
     def test_tip_changeset_in_tags(self):
         tip = self.repo.get_changeset()
-        self.assertEqual(self.repo.tags['tip'], tip.raw_id)
+        assert self.repo.tags['tip'] == tip.raw_id
 
     def test_initial_changeset(self):
 
         init_chset = self.repo.get_changeset(0)
-        self.assertEqual(init_chset.message, 'initial import')
-        self.assertEqual(init_chset.author,
-            'Marcin Kuzminski <[e-mail]>')
-        self.assertEqual(sorted(init_chset._file_paths),
-            sorted([
-                'vcs/__init__.py',
-                'vcs/backends/BaseRepository.py',
-                'vcs/backends/__init__.py',
-            ])
-        )
-        self.assertEqual(sorted(init_chset._dir_paths),
-            sorted(['', 'vcs', 'vcs/backends']))
+        assert init_chset.message == 'initial import'
+        assert init_chset.author == 'Marcin Kuzminski <[e-mail]>'
+        assert sorted(init_chset._file_paths) == sorted([
+            'vcs/__init__.py',
+            'vcs/backends/BaseRepository.py',
+            'vcs/backends/__init__.py',
+        ])
 
-        self.assertRaises(NodeDoesNotExistError, init_chset.get_node, path='foobar')
+        assert sorted(init_chset._dir_paths) == sorted(['', 'vcs', 'vcs/backends'])
+
+        with pytest.raises(NodeDoesNotExistError):
+            init_chset.get_node(path='foobar')
 
         node = init_chset.get_node('vcs/')
-        self.assertTrue(hasattr(node, 'kind'))
-        self.assertEqual(node.kind, NodeKind.DIR)
+        assert hasattr(node, 'kind')
+        assert node.kind == NodeKind.DIR
 
         node = init_chset.get_node('vcs')
-        self.assertTrue(hasattr(node, 'kind'))
-        self.assertEqual(node.kind, NodeKind.DIR)
+        assert hasattr(node, 'kind')
+        assert node.kind == NodeKind.DIR
 
         node = init_chset.get_node('vcs/__init__.py')
-        self.assertTrue(hasattr(node, 'kind'))
-        self.assertEqual(node.kind, NodeKind.FILE)
+        assert hasattr(node, 'kind')
+        assert node.kind == NodeKind.FILE
 
     def test_not_existing_changeset(self):
         # rawid
-        self.assertRaises(RepositoryError, self.repo.get_changeset,
-            'abcd' * 10)
+        with pytest.raises(RepositoryError):
+            self.repo.get_changeset('abcd' * 10)
         # shortid
-        self.assertRaises(RepositoryError, self.repo.get_changeset,
-            'erro' * 4)
+        with pytest.raises(RepositoryError):
+            self.repo.get_changeset('erro' * 4)
         # numeric
-        self.assertRaises(RepositoryError, self.repo.get_changeset,
-            self.repo.count() + 1)
-
+        with pytest.raises(RepositoryError):
+            self.repo.get_changeset(self.repo.count() + 1)
 
         # Small chance we ever get to this one
         revision = pow(2, 30)
-        self.assertRaises(RepositoryError, self.repo.get_changeset, revision)
+        with pytest.raises(RepositoryError):
+            self.repo.get_changeset(revision)
 
     def test_changeset10(self):
 
@@ -231,21 +233,20 b' TODO: To be written...'
 
 """
         node = chset10.get_node('README.rst')
-        self.assertEqual(node.kind, NodeKind.FILE)
-        self.assertEqual(node.content, readme)
+        assert node.kind == NodeKind.FILE
+        assert node.content == readme
 
 
-class MercurialChangesetTest(unittest.TestCase):
+class TestMercurialChangeset(object):
 
-    def setUp(self):
+    def setup_method(self):
         self.repo = MercurialRepository(safe_str(TEST_HG_REPO))
 
     def _test_equality(self, changeset):
         revision = changeset.revision
-        self.assertEqual(changeset, self.repo.get_changeset(revision))
+        assert changeset == self.repo.get_changeset(revision)
 
     def test_equality(self):
-        self.setUp()
         revs = [0, 10, 20]
         changesets = [self.repo.get_changeset(rev) for rev in revs]
         for changeset in changesets:
@@ -253,13 +254,13 b' class MercurialChangesetTest(unittest.Te'
 
     def test_default_changeset(self):
         tip = self.repo.get_changeset('tip')
-        self.assertEqual(tip, self.repo.get_changeset())
-        self.assertEqual(tip, self.repo.get_changeset(revision=None))
-        self.assertEqual(tip, list(self.repo[-1:])[0])
+        assert tip == self.repo.get_changeset()
+        assert tip == self.repo.get_changeset(revision=None)
+        assert tip == list(self.repo[-1:])[0]
 
     def test_root_node(self):
         tip = self.repo.get_changeset('tip')
-        self.assertTrue(tip.root is tip.get_node(''))
+        assert tip.root is tip.get_node('')
 
     def test_lazy_fetch(self):
         """
@@ -267,60 +268,56 b' class MercurialChangesetTest(unittest.Te'
         the revision. This test is somewhat hard to write as order of tests
         is a key here. Written by running command after command in a shell.
         """
-        self.setUp()
         chset = self.repo.get_changeset(45)
-        self.assertTrue(len(chset.nodes) == 0)
+        assert len(chset.nodes) == 0
         root = chset.root
-        self.assertTrue(len(chset.nodes) == 1)
-        self.assertTrue(len(root.nodes) == 8)
+        assert len(chset.nodes) == 1
+        assert len(root.nodes) == 8
         # accessing root.nodes updates chset.nodes
-        self.assertTrue(len(chset.nodes) == 9)
+        assert len(chset.nodes) == 9
 
         docs = root.get_node('docs')
         # we haven't yet accessed anything new as docs dir was already cached
-        self.assertTrue(len(chset.nodes) == 9)
-        self.assertTrue(len(docs.nodes) == 8)
+        assert len(chset.nodes) == 9
+        assert len(docs.nodes) == 8
         # accessing docs.nodes updates chset.nodes
-        self.assertTrue(len(chset.nodes) == 17)
+        assert len(chset.nodes) == 17
 
-        self.assertTrue(docs is chset.get_node('docs'))
-        self.assertTrue(docs is root.nodes[0])
-        self.assertTrue(docs is root.dirs[0])
-        self.assertTrue(docs is chset.get_node('docs'))
+        assert docs is chset.get_node('docs')
+        assert docs is root.nodes[0]
+        assert docs is root.dirs[0]
+        assert docs is chset.get_node('docs')
 
     def test_nodes_with_changeset(self):
-        self.setUp()
         chset = self.repo.get_changeset(45)
         root = chset.root
         docs = root.get_node('docs')
-        self.assertTrue(docs is chset.get_node('docs'))
+        assert docs is chset.get_node('docs')
         api = docs.get_node('api')
-        self.assertTrue(api is chset.get_node('docs/api'))
+        assert api is chset.get_node('docs/api')
         index = api.get_node('index.rst')
-        self.assertTrue(index is chset.get_node('docs/api/index.rst'))
-        self.assertTrue(index is chset.get_node('docs') \
-            .get_node('api') \
-            .get_node('index.rst'))
+        assert index is chset.get_node('docs/api/index.rst')
+        assert index is chset.get_node('docs').get_node('api').get_node('index.rst')
 
     def test_branch_and_tags(self):
         chset0 = self.repo.get_changeset(0)
-        self.assertEqual(chset0.branch, 'default')
-        self.assertEqual(chset0.tags, [])
+        assert chset0.branch == 'default'
+        assert chset0.tags == []
 
         chset10 = self.repo.get_changeset(10)
-        self.assertEqual(chset10.branch, 'default')
-        self.assertEqual(chset10.tags, [])
+        assert chset10.branch == 'default'
+        assert chset10.tags == []
 
         chset44 = self.repo.get_changeset(44)
-        self.assertEqual(chset44.branch, 'web')
+        assert chset44.branch == 'web'
 
         tip = self.repo.get_changeset('tip')
-        self.assertTrue('tip' in tip.tags)
+        assert 'tip' in tip.tags
 
     def _test_file_size(self, revision, path, size):
         node = self.repo.get_changeset(revision).get_node(path)
-        self.assertTrue(node.is_file())
-        self.assertEqual(node.size, size)
+        assert node.is_file()
+        assert node.size == size
 
     def test_file_size(self):
         to_check = (
@@ -337,8 +334,8 b' class MercurialChangesetTest(unittest.Te'
 
     def _test_dir_size(self, revision, path, size):
         node = self.repo.get_changeset(revision).get_node(path)
-        self.assertFalse(node.is_file())
-        self.assertEqual(node.size, size)
+        assert not node.is_file()
+        assert node.size == size
 
     def test_dir_size(self):
         to_check = (
@@ -350,7 +347,7 b' class MercurialChangesetTest(unittest.Te'
             self._test_dir_size(revision, path, size)
 
     def test_repo_size(self):
-        self.assertEqual(self.repo.size, 682421)
+        assert self.repo.size == 682421
 
     def test_file_history(self):
         # we can only check if those revisions are present in the history
@@ -368,10 +365,10 b' class MercurialChangesetTest(unittest.Te'
             tip = self.repo.get_changeset(revs[-1])
             node = tip.get_node(path)
             node_revs = [chset.revision for chset in node.history]
-            self.assertTrue(set(revs).issubset(set(node_revs)),
-                "We assumed that %s is subset of revisions for which file %s "
-                "has been changed, and history of that node returned: %s"
-                % (revs, path, node_revs))
+            assert set(revs).issubset(set(node_revs)), \
+                "We assumed that %s is subset of revisions for which file %s " \
+                "has been changed, and history of that node returned: %s" \
+                % (revs, path, node_revs)
 
     def test_file_annotate(self):
         files = {
@@ -410,12 +407,12 b' class MercurialChangesetTest(unittest.Te'
                 cs = self.repo.get_changeset(rev)
                 l1_1 = [x[1] for x in cs.get_file_annotate(fname)]
                 l1_2 = [x[2]().raw_id for x in cs.get_file_annotate(fname)]
-                self.assertEqual(l1_1, l1_2)
+                assert l1_1 == l1_2
                 l1 = l1_2 = [x[2]().revision for x in cs.get_file_annotate(fname)]
                 l2 = files[fname][rev]['changesets']
-                self.assertTrue(l1 == l2, "The lists of revision for %s@rev%s"
-                                "from annotation list should match each other,"
-                                "got \n%s \nvs \n%s " % (fname, rev, l1, l2))
+                assert l1 == l2, "The lists of revision for %s@rev%s" \
+                    "from annotation list should match each other," \
+                    "got \n%s \nvs \n%s " % (fname, rev, l1, l2)
 
     def test_changeset_state(self):
         """
@@ -447,9 +444,9 b' class MercurialChangesetTest(unittest.Te'
         removed = set(['docs/api.rst'])
 
         chset64 = self.repo.get_changeset('46ad32a4f974')
-        self.assertEqual(set((node.path for node in chset64.added)), added)
-        self.assertEqual(set((node.path for node in chset64.changed)), changed)
-        self.assertEqual(set((node.path for node in chset64.removed)), removed)
+        assert set((node.path for node in chset64.added)) == added
+        assert set((node.path for node in chset64.changed)) == changed
+        assert set((node.path for node in chset64.removed)) == removed
 
         # rev b090f22d27d6:
         # hg st --rev b090f22d27d6
@@ -457,27 +454,30 b' class MercurialChangesetTest(unittest.Te'
         #    added:   20
         #    removed: 1
         chset88 = self.repo.get_changeset('b090f22d27d6')
-        self.assertEqual(set((node.path for node in chset88.added)), set())
-        self.assertEqual(set((node.path for node in chset88.changed)),
-            set(['.hgignore']))
-        self.assertEqual(set((node.path for node in chset88.removed)), set())
+        assert set((node.path for node in chset88.added)) == set()
+        assert set((node.path for node in chset88.changed)) == set(['.hgignore'])
+        assert set((node.path for node in chset88.removed)) == set()
 
         # 85:
         #    added:   2 ['vcs/utils/diffs.py', 'vcs/web/simplevcs/views/diffs.py']
         #    changed: 4 ['vcs/web/simplevcs/models.py', ...]
         #    removed: 1 ['vcs/utils/web.py']
         chset85 = self.repo.get_changeset(85)
-        self.assertEqual(set((node.path for node in chset85.added)), set([
+        assert set((node.path for node in chset85.added)) == set([
             'vcs/utils/diffs.py',
-            'vcs/web/simplevcs/views/diffs.py']))
-        self.assertEqual(set((node.path for node in chset85.changed)), set([
+            'vcs/web/simplevcs/views/diffs.py'
+        ])
+
+        assert set((node.path for node in chset85.changed)) == set([
             'vcs/web/simplevcs/models.py',
             'vcs/web/simplevcs/utils.py',
             'vcs/web/simplevcs/views/__init__.py',
             'vcs/web/simplevcs/views/repository.py',
-            ]))
-        self.assertEqual(set((node.path for node in chset85.removed)),
-            set(['vcs/utils/web.py']))
+        ])
+
+        assert set((node.path for node in chset85.removed)) == set([
+            'vcs/utils/web.py'
+        ])
 
 
     def test_files_state(self):
@@ -486,54 +486,56 b' class MercurialChangesetTest(unittest.Te'
         """
         chset = self.repo.get_changeset(85)
         node = chset.get_node('vcs/utils/diffs.py')
-        self.assertTrue(node.state, NodeState.ADDED)
-        self.assertTrue(node.added)
-        self.assertFalse(node.changed)
-        self.assertFalse(node.not_changed)
-        self.assertFalse(node.removed)
+        assert node.state, NodeState.ADDED
+        assert node.added
+        assert not node.changed
+        assert not node.not_changed
+        assert not node.removed
 
         chset = self.repo.get_changeset(88)
         node = chset.get_node('.hgignore')
-        self.assertTrue(node.state, NodeState.CHANGED)
-        self.assertFalse(node.added)
-        self.assertTrue(node.changed)
-        self.assertFalse(node.not_changed)
-        self.assertFalse(node.removed)
+        assert node.state, NodeState.CHANGED
+        assert not node.added
+        assert node.changed
+        assert not node.not_changed
+        assert not node.removed
 
         chset = self.repo.get_changeset(85)
         node = chset.get_node('setup.py')
-        self.assertTrue(node.state, NodeState.NOT_CHANGED)
-        self.assertFalse(node.added)
-        self.assertFalse(node.changed)
-        self.assertTrue(node.not_changed)
-        self.assertFalse(node.removed)
+        assert node.state, NodeState.NOT_CHANGED
+        assert not node.added
+        assert not node.changed
+        assert node.not_changed
+        assert not node.removed
 
         # If node has REMOVED state then trying to fetch it would raise
         # ChangesetError exception
         chset = self.repo.get_changeset(2)
         path = 'vcs/backends/BaseRepository.py'
-        self.assertRaises(NodeDoesNotExistError, chset.get_node, path)
+        with pytest.raises(NodeDoesNotExistError):
+            chset.get_node(path)
         # but it would be one of ``removed`` (changeset's attribute)
-        self.assertTrue(path in [rf.path for rf in chset.removed])
+        assert path in [rf.path for rf in chset.removed]
 
     def test_commit_message_is_unicode(self):
         for cm in self.repo:
-            self.assertEqual(type(cm.message), unicode)
+            assert type(cm.message) == unicode
 
     def test_changeset_author_is_unicode(self):
         for cm in self.repo:
-            self.assertEqual(type(cm.author), unicode)
+            assert type(cm.author) == unicode
 
     def test_repo_files_content_is_unicode(self):
         test_changeset = self.repo.get_changeset(100)
         for node in test_changeset.get_node('/'):
             if node.is_file():
-                self.assertEqual(type(node.content), unicode)
+                assert type(node.content) == unicode
 
     def test_wrong_path(self):
         # There is 'setup.py' in the root dir but not there:
         path = 'foo/bar/setup.py'
-        self.assertRaises(VCSError, self.repo.get_changeset().get_node, path)
+        with pytest.raises(VCSError):
+            self.repo.get_changeset().get_node(path)
 
     def test_archival_file(self):
         # TODO:
@@ -545,24 +547,19 b' class MercurialChangesetTest(unittest.Te'
 
     def test_archival_wrong_kind(self):
         tip = self.repo.get_changeset()
-        self.assertRaises(VCSError, tip.fill_archive, kind='error')
+        with pytest.raises(VCSError):
+            tip.fill_archive(kind='error')
 
     def test_archival_empty_prefix(self):
         # TODO:
         pass
 
     def test_author_email(self):
-        self.assertEqual('[e-mail]',
-                         self.repo.get_changeset('b986218ba1c9').author_email)
-        self.assertEqual('[e-mail]',
-                         self.repo.get_changeset('3803844fdbd3').author_email)
-        self.assertEqual('',
-                         self.repo.get_changeset('84478366594b').author_email)
+        assert '[e-mail]' == self.repo.get_changeset('b986218ba1c9').author_email
+        assert '[e-mail]' == self.repo.get_changeset('3803844fdbd3').author_email
+        assert '' == self.repo.get_changeset('84478366594b').author_email
 
     def test_author_username(self):
-        self.assertEqual('Marcin Kuzminski',
-                         self.repo.get_changeset('b986218ba1c9').author_name)
-        self.assertEqual('Lukasz Balcerzak',
-                         self.repo.get_changeset('3803844fdbd3').author_name)
-        self.assertEqual('marcink',
-                         self.repo.get_changeset('84478366594b').author_name)
+        assert 'Marcin Kuzminski' == self.repo.get_changeset('b986218ba1c9').author_name
+        assert 'Lukasz Balcerzak' == self.repo.get_changeset('3803844fdbd3').author_name
+        assert 'marcink' == self.repo.get_changeset('84478366594b').author_name