tests: update _BackendTestMixin to py.test and convert tests using it from self.assert to plain py.test style asserts

kallithea/tests/vcs/base.py

@@ -1,108 +1,106 b''
 """
 Module providing backend independent mixin class. It requires that
 InMemoryChangeset class is working properly at backend class.
 """
 import os
 import time
 import shutil
 import datetime
 
 from kallithea.lib import vcs
-from kallithea.lib.vcs.utils.compat import unittest
 from kallithea.lib.vcs.nodes import FileNode
 
 from kallithea.tests.vcs.conf import SCM_TESTS, get_new_dir
 
 
 class _BackendTestMixin(object):
     """
     This is a backend independent test case class which should be created
     with ``type`` method.
 
     It is required to set following attributes at subclass:
 
     - ``backend_alias``: alias of used backend (see ``vcs.BACKENDS``)
     - ``repo_path``: path to the repository which would be created for set of
       tests
     - ``recreate_repo_per_test``: If set to ``False``, repo would NOT be created
       before every single test. Defaults to ``True``.
     """
     recreate_repo_per_test = True
 
     @classmethod
     def get_backend(cls):
         return vcs.get_backend(cls.backend_alias)
 
     @classmethod
     def _get_commits(cls):
         commits = [
             {
                 'message': u'Initial commit',
                 'author': u'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foobar', content='Foobar'),
                     FileNode('foobar2', content='Foobar II'),
                     FileNode('foo/bar/baz', content='baz here!'),
                 ],
             },
             {
                 'message': u'Changes...',
                 'author': u'Jane Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 21),
                 'added': [
                     FileNode('some/new.txt', content='news...'),
                 ],
                 'changed': [
                     FileNode('foobar', 'Foobar I'),
                 ],
                 'removed': [],
             },
         ]
         return commits
 
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         Backend = cls.get_backend()
         cls.backend_class = Backend
         cls.repo_path = get_new_dir(str(time.time()))
         cls.repo = Backend(cls.repo_path, create=True)
         cls.imc = cls.repo.in_memory_changeset
         cls.default_branch = cls.repo.DEFAULT_BRANCH_NAME
 
         for commit in cls._get_commits():
             for node in commit.get('added', []):
                 cls.imc.add(FileNode(node.path, content=node.content))
             for node in commit.get('changed', []):
                 cls.imc.change(FileNode(node.path, content=node.content))
             for node in commit.get('removed', []):
                 cls.imc.remove(FileNode(node.path))
 
             cls.tip = cls.imc.commit(message=unicode(commit['message']),
                                      author=unicode(commit['author']),
                                      date=commit['date'])
 
     @classmethod
-    def tearDownClass(cls):
+    def teardown_class(cls):
         if not getattr(cls, 'recreate_repo_per_test', False) and \
             'VCS_REMOVE_TEST_DIRS' in os.environ:
             shutil.rmtree(cls.repo_path)
 
-    def setUp(self):
+    def setup_method(self, method):
         if getattr(self, 'recreate_repo_per_test', False):
-            self.__class__.setUpClass()
+            self.__class__.setup_class()
 
-    def tearDown(self):
+    def teardown_method(self, method):
         if getattr(self, 'recreate_repo_per_test', False) and \
             'VCS_REMOVE_TEST_DIRS' in os.environ:
             shutil.rmtree(self.repo_path)
 
 
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
     cls_name = ''.join(('%s base backend test' % alias).title().split())
-    bases = (_BackendTestMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    globals()[cls_name] = type(cls_name, (_BackendTestMixin,), attrs)

kallithea/tests/vcs/test_archives.py

@@ -1,113 +1,106 b''
 import os
 import tarfile
 import zipfile
 import datetime
 import tempfile
 import StringIO
 
-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 
 from kallithea.lib.vcs.exceptions import VCSError
 from kallithea.lib.vcs.nodes import FileNode
 
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS, TESTS_TMP_PATH
 
 
 class ArchivesTestCaseMixin(_BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': 'Commit %d' % x,
                 'author': 'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('%d/file_%d.txt' % (x, x),
                         content='Foobar %d' % x),
                 ],
             }
 
     def test_archive_zip(self):
         path = tempfile.mkstemp(dir=TESTS_TMP_PATH, prefix='test_archive_zip-')[1]
         with open(path, 'wb') as f:
             self.tip.fill_archive(stream=f, kind='zip', prefix='repo')
         out = zipfile.ZipFile(path)
 
         for x in xrange(5):
             node_path = '%d/file_%d.txt' % (x, x)
             decompressed = StringIO.StringIO()
             decompressed.write(out.read('repo/' + node_path))
-            self.assertEqual(
-                decompressed.getvalue(),
-                self.tip.get_node(node_path).content)
+            assert decompressed.getvalue() == self.tip.get_node(node_path).content
 
     def test_archive_tgz(self):
         path = tempfile.mkstemp(dir=TESTS_TMP_PATH, prefix='test_archive_tgz-')[1]
         with open(path, 'wb') as f:
             self.tip.fill_archive(stream=f, kind='tgz', prefix='repo')
         outdir = tempfile.mkdtemp(dir=TESTS_TMP_PATH, prefix='test_archive_tgz-', suffix='-outdir')
 
         outfile = tarfile.open(path, 'r|gz')
         outfile.extractall(outdir)
 
         for x in xrange(5):
             node_path = '%d/file_%d.txt' % (x, x)
-            self.assertEqual(
-                open(os.path.join(outdir, 'repo/' + node_path)).read(),
-                self.tip.get_node(node_path).content)
+            assert open(os.path.join(outdir, 'repo/' + node_path)).read() == self.tip.get_node(node_path).content
 
     def test_archive_tbz2(self):
         path = tempfile.mkstemp(dir=TESTS_TMP_PATH, prefix='test_archive_tbz2-')[1]
         with open(path, 'w+b') as f:
             self.tip.fill_archive(stream=f, kind='tbz2', prefix='repo')
         outdir = tempfile.mkdtemp(dir=TESTS_TMP_PATH, prefix='test_archive_tbz2-', suffix='-outdir')
 
         outfile = tarfile.open(path, 'r|bz2')
         outfile.extractall(outdir)
 
         for x in xrange(5):
             node_path = '%d/file_%d.txt' % (x, x)
-            self.assertEqual(
-                open(os.path.join(outdir, 'repo/' + node_path)).read(),
-                self.tip.get_node(node_path).content)
+            assert open(os.path.join(outdir, 'repo/' + node_path)).read() == self.tip.get_node(node_path).content
 
     def test_archive_default_stream(self):
         tmppath = tempfile.mkstemp(dir=TESTS_TMP_PATH, prefix='test_archive_default_stream-')[1]
         with open(tmppath, 'wb') as stream:
             self.tip.fill_archive(stream=stream)
         mystream = StringIO.StringIO()
         self.tip.fill_archive(stream=mystream)
         mystream.seek(0)
         with open(tmppath, 'rb') as f:
             file_content = f.read()
             stringio_content = mystream.read()
             # the gzip header contains a MTIME header
             # because is takes a little bit of time from one fill_archive call to the next
             # this part may differ so don't include that part in the comparison
-            self.assertEqual(file_content[:4], stringio_content[:4])
-            self.assertEqual(file_content[8:], stringio_content[8:])
+            assert file_content[:4] == stringio_content[:4]
+            assert file_content[8:] == stringio_content[8:]
 
     def test_archive_wrong_kind(self):
-        with self.assertRaises(VCSError):
+        with pytest.raises(VCSError):
             self.tip.fill_archive(kind='wrong kind')
 
     def test_archive_empty_prefix(self):
-        with self.assertRaises(VCSError):
+        with pytest.raises(VCSError):
             self.tip.fill_archive(prefix='')
 
     def test_archive_prefix_with_leading_slash(self):
-        with self.assertRaises(VCSError):
+        with pytest.raises(VCSError):
             self.tip.fill_archive(prefix='/any')
 
 
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
-    cls_name = ''.join(('%s archive test' % alias).title().split())
-    bases = (ArchivesTestCaseMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = ''.join(('test %s archive' % alias).title().split())
+    globals()[cls_name] = type(cls_name, (ArchivesTestCaseMixin,), attrs)

kallithea/tests/vcs/test_branches.py

@@ -1,111 +1,108 b''
 import datetime
 from kallithea.lib import vcs
-from kallithea.lib.vcs.utils.compat import unittest
 from kallithea.lib.vcs.nodes import FileNode
 
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS
 
 
 class BranchesTestCaseMixin(_BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         commits = [
             {
                 'message': 'Initial commit',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foobar', content='Foobar'),
                     FileNode('foobar2', content='Foobar II'),
                     FileNode('foo/bar/baz', content='baz here!'),
                 ],
             },
             {
                 'message': 'Changes...',
                 'author': 'Jane Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 21),
                 'added': [
                     FileNode('some/new.txt', content='news...'),
                 ],
                 'changed': [
                     FileNode('foobar', 'Foobar I'),
                 ],
                 'removed': [],
             },
         ]
         return commits
 
     def test_simple(self):
         tip = self.repo.get_changeset()
-        self.assertEqual(tip.date, datetime.datetime(2010, 1, 1, 21))
+        assert tip.date == datetime.datetime(2010, 1, 1, 21)
 
     def test_new_branch(self):
         # This check must not be removed to ensure the 'branches' LazyProperty
         # gets hit *before* the new 'foobar' branch got created:
-        self.assertFalse('foobar' in self.repo.branches)
+        assert 'foobar' not in self.repo.branches
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
         )
-        self.assertTrue('foobar' in self.repo.branches)
-        self.assertEqual(foobar_tip.branch, 'foobar')
+        assert 'foobar' in self.repo.branches
+        assert foobar_tip.branch == 'foobar'
 
     def test_new_head(self):
         tip = self.repo.get_changeset()
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
             parents=[tip],
         )
         self.imc.change(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\nand more...\n'))
         newtip = self.imc.commit(
             message=u'At default branch',
             author=u'joe',
             branch=foobar_tip.branch,
             parents=[foobar_tip],
         )
 
         newest_tip = self.imc.commit(
             message=u'Merged with %s' % foobar_tip.raw_id,
             author=u'joe',
             branch=self.backend_class.DEFAULT_BRANCH_NAME,
             parents=[newtip, foobar_tip],
         )
 
-        self.assertEqual(newest_tip.branch,
-            self.backend_class.DEFAULT_BRANCH_NAME)
+        assert newest_tip.branch == self.backend_class.DEFAULT_BRANCH_NAME
 
     def test_branch_with_slash_in_name(self):
         self.imc.add(vcs.nodes.FileNode('extrafile', content='Some data\n'))
         self.imc.commit(u'Branch with a slash!', author=u'joe',
             branch='issue/123')
-        self.assertTrue('issue/123' in self.repo.branches)
+        assert 'issue/123' in self.repo.branches
 
     def test_branch_with_slash_in_name_and_similar_without(self):
         self.imc.add(vcs.nodes.FileNode('extrafile', content='Some data\n'))
         self.imc.commit(u'Branch with a slash!', author=u'joe',
             branch='issue/123')
         self.imc.add(vcs.nodes.FileNode('extrafile II', content='Some data\n'))
         self.imc.commit(u'Branch without a slash...', author=u'joe',
             branch='123')
-        self.assertIn('issue/123', self.repo.branches)
-        self.assertIn('123', self.repo.branches)
+        assert 'issue/123' in self.repo.branches
+        assert '123' in self.repo.branches
 
 
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
-    cls_name = ''.join(('%s branches test' % alias).title().split())
-    bases = (BranchesTestCaseMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = ''.join(('test %s branches' % alias).title().split())
+    globals()[cls_name] = type(cls_name, (BranchesTestCaseMixin,), attrs)

kallithea/tests/vcs/test_changesets.py

@@ -1,392 +1,390 b''
 # encoding: utf8
 
 import time
 import datetime
 
-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 
 from kallithea.lib import vcs
 
 from kallithea.lib.vcs.backends.base import BaseChangeset
 from kallithea.lib.vcs.nodes import (
     FileNode, AddedFileNodesGenerator,
     ChangedFileNodesGenerator, RemovedFileNodesGenerator
 )
 from kallithea.lib.vcs.exceptions import (
     BranchDoesNotExistError, ChangesetDoesNotExistError,
     RepositoryError, EmptyRepositoryError
 )
 
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS, get_new_dir
 
 
-class TestBaseChangeset(unittest.TestCase):
+class TestBaseChangeset(object):
 
     def test_as_dict(self):
         changeset = BaseChangeset()
         changeset.id = 'ID'
         changeset.raw_id = 'RAW_ID'
         changeset.short_id = 'SHORT_ID'
         changeset.revision = 1009
         changeset.date = datetime.datetime(2011, 1, 30, 1, 45)
         changeset.message = 'Message of a commit'
         changeset.author = 'Joe Doe <[e-mail]>'
         changeset.added = [FileNode('foo/bar/baz'), FileNode(u'foobar'), FileNode(u'blåbærgrød')]
         changeset.changed = []
         changeset.removed = []
-        self.assertEqual(changeset.as_dict(), {
+        assert changeset.as_dict() == {
             'id': 'ID',
             'raw_id': 'RAW_ID',
             'short_id': 'SHORT_ID',
             'revision': 1009,
             'date': datetime.datetime(2011, 1, 30, 1, 45),
             'message': 'Message of a commit',
             'author': {
                 'name': 'Joe Doe',
                 'email': '[e-mail]',
             },
             'added': ['foo/bar/baz', 'foobar', u'bl\xe5b\xe6rgr\xf8d'],
             'changed': [],
             'removed': [],
-        })
+        }
 
 
 class _ChangesetsWithCommitsTestCaseixin(_BackendTestMixin):
     recreate_repo_per_test = True
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': 'Commit %d' % x,
                 'author': 'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
             }
 
     def test_new_branch(self):
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
         )
-        self.assertTrue('foobar' in self.repo.branches)
-        self.assertEqual(foobar_tip.branch, 'foobar')
+        assert 'foobar' in self.repo.branches
+        assert foobar_tip.branch == 'foobar'
         # 'foobar' should be the only branch that contains the new commit
-        self.assertNotEqual(*self.repo.branches.values())
+        branches = self.repo.branches.values()
+        assert branches[0] != branches[1]
 
     def test_new_head_in_default_branch(self):
         tip = self.repo.get_changeset()
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
             parents=[tip],
         )
         self.imc.change(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\nand more...\n'))
         newtip = self.imc.commit(
             message=u'At default branch',
             author=u'joe',
             branch=foobar_tip.branch,
             parents=[foobar_tip],
         )
 
         newest_tip = self.imc.commit(
             message=u'Merged with %s' % foobar_tip.raw_id,
             author=u'joe',
             branch=self.backend_class.DEFAULT_BRANCH_NAME,
             parents=[newtip, foobar_tip],
         )
 
-        self.assertEqual(newest_tip.branch,
-            self.backend_class.DEFAULT_BRANCH_NAME)
+        assert newest_tip.branch == self.backend_class.DEFAULT_BRANCH_NAME
 
     def test_get_changesets_respects_branch_name(self):
         tip = self.repo.get_changeset()
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         doc_changeset = self.imc.commit(
             message=u'New branch: docs',
             author=u'joe',
             branch='docs',
         )
         self.imc.add(vcs.nodes.FileNode('newfile', content=''))
         self.imc.commit(
             message=u'Back in default branch',
             author=u'joe',
             parents=[tip],
         )
         default_branch_changesets = self.repo.get_changesets(
             branch_name=self.repo.DEFAULT_BRANCH_NAME)
-        self.assertNotIn(doc_changeset, default_branch_changesets)
+        assert doc_changeset not in default_branch_changesets
 
     def test_get_changeset_by_branch(self):
         for branch, sha in self.repo.branches.iteritems():
-            self.assertEqual(sha, self.repo.get_changeset(branch).raw_id)
+            assert sha == self.repo.get_changeset(branch).raw_id
 
     def test_get_changeset_by_tag(self):
         for tag, sha in self.repo.tags.iteritems():
-            self.assertEqual(sha, self.repo.get_changeset(tag).raw_id)
+            assert sha == self.repo.get_changeset(tag).raw_id
 
     def test_get_changeset_parents(self):
         for test_rev in [1, 2, 3]:
             sha = self.repo.get_changeset(test_rev-1)
-            self.assertEqual([sha], self.repo.get_changeset(test_rev).parents)
+            assert [sha] == self.repo.get_changeset(test_rev).parents
 
     def test_get_changeset_children(self):
         for test_rev in [1, 2, 3]:
             sha = self.repo.get_changeset(test_rev+1)
-            self.assertEqual([sha], self.repo.get_changeset(test_rev).children)
+            assert [sha] == self.repo.get_changeset(test_rev).children
 
 
 class _ChangesetsTestCaseMixin(_BackendTestMixin):
     recreate_repo_per_test = False
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': u'Commit %d' % x,
                 'author': u'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
             }
 
     def test_simple(self):
         tip = self.repo.get_changeset()
-        self.assertEqual(tip.date, datetime.datetime(2010, 1, 3, 20))
+        assert tip.date == datetime.datetime(2010, 1, 3, 20)
 
     def test_get_changesets_is_ordered_by_date(self):
         changesets = list(self.repo.get_changesets())
         ordered_by_date = sorted(changesets,
             key=lambda cs: cs.date)
-        self.assertItemsEqual(changesets, ordered_by_date)
+
+        assert changesets == ordered_by_date
 
     def test_get_changesets_respects_start(self):
         second_id = self.repo.revisions[1]
         changesets = list(self.repo.get_changesets(start=second_id))
-        self.assertEqual(len(changesets), 4)
+        assert len(changesets) == 4
 
     def test_get_changesets_numerical_id_respects_start(self):
         second_id = 1
         changesets = list(self.repo.get_changesets(start=second_id))
-        self.assertEqual(len(changesets), 4)
+        assert len(changesets) == 4
 
     def test_get_changesets_includes_start_changeset(self):
         second_id = self.repo.revisions[1]
         changesets = list(self.repo.get_changesets(start=second_id))
-        self.assertEqual(changesets[0].raw_id, second_id)
+        assert changesets[0].raw_id == second_id
 
     def test_get_changesets_respects_end(self):
         second_id = self.repo.revisions[1]
         changesets = list(self.repo.get_changesets(end=second_id))
-        self.assertEqual(changesets[-1].raw_id, second_id)
-        self.assertEqual(len(changesets), 2)
+        assert changesets[-1].raw_id == second_id
+        assert len(changesets) == 2
 
     def test_get_changesets_numerical_id_respects_end(self):
         second_id = 1
         changesets = list(self.repo.get_changesets(end=second_id))
-        self.assertEqual(changesets.index(changesets[-1]), second_id)
-        self.assertEqual(len(changesets), 2)
+        assert changesets.index(changesets[-1]) == second_id
+        assert len(changesets) == 2
 
     def test_get_changesets_respects_both_start_and_end(self):
         second_id = self.repo.revisions[1]
         third_id = self.repo.revisions[2]
         changesets = list(self.repo.get_changesets(start=second_id,
             end=third_id))
-        self.assertEqual(len(changesets), 2)
+        assert len(changesets) == 2
 
     def test_get_changesets_numerical_id_respects_both_start_and_end(self):
         changesets = list(self.repo.get_changesets(start=2, end=3))
-        self.assertEqual(len(changesets), 2)
+        assert len(changesets) == 2
 
     def test_get_changesets_on_empty_repo_raises_EmptyRepository_error(self):
         Backend = self.get_backend()
         repo_path = get_new_dir(str(time.time()))
         repo = Backend(repo_path, create=True)
 
-        with self.assertRaises(EmptyRepositoryError):
+        with pytest.raises(EmptyRepositoryError):
             list(repo.get_changesets(start='foobar'))
 
     def test_get_changesets_includes_end_changeset(self):
         second_id = self.repo.revisions[1]
         changesets = list(self.repo.get_changesets(end=second_id))
-        self.assertEqual(changesets[-1].raw_id, second_id)
+        assert changesets[-1].raw_id == second_id
 
     def test_get_changesets_respects_start_date(self):
         start_date = datetime.datetime(2010, 2, 1)
         for cs in self.repo.get_changesets(start_date=start_date):
-            self.assertGreaterEqual(cs.date, start_date)
+            assert cs.date >= start_date
 
     def test_get_changesets_respects_end_date(self):
         start_date = datetime.datetime(2010, 1, 1)
         end_date = datetime.datetime(2010, 2, 1)
         for cs in self.repo.get_changesets(start_date=start_date,
                                            end_date=end_date):
-            self.assertGreaterEqual(cs.date, start_date)
-            self.assertLessEqual(cs.date, end_date)
+            assert cs.date >= start_date
+            assert cs.date <= end_date
 
     def test_get_changesets_respects_start_date_and_end_date(self):
         end_date = datetime.datetime(2010, 2, 1)
         for cs in self.repo.get_changesets(end_date=end_date):
-            self.assertLessEqual(cs.date, end_date)
+            assert cs.date <= end_date
 
     def test_get_changesets_respects_reverse(self):
         changesets_id_list = [cs.raw_id for cs in
             self.repo.get_changesets(reverse=True)]
-        self.assertItemsEqual(changesets_id_list, reversed(self.repo.revisions))
+        assert changesets_id_list == list(reversed(self.repo.revisions))
 
     def test_get_filenodes_generator(self):
         tip = self.repo.get_changeset()
         filepaths = [node.path for node in tip.get_filenodes_generator()]
-        self.assertItemsEqual(filepaths, ['file_%d.txt' % x for x in xrange(5)])
+        assert filepaths == ['file_%d.txt' % x for x in xrange(5)]
 
     def test_size(self):
         tip = self.repo.get_changeset()
         size = 5 * len('Foobar N') # Size of 5 files
-        self.assertEqual(tip.size, size)
+        assert tip.size == size
 
     def test_author(self):
         tip = self.repo.get_changeset()
-        self.assertEqual(tip.author, u'Joe Doe <[e-mail]>')
+        assert tip.author == u'Joe Doe <[e-mail]>'
 
     def test_author_name(self):
         tip = self.repo.get_changeset()
-        self.assertEqual(tip.author_name, u'Joe Doe')
+        assert tip.author_name == u'Joe Doe'
 
     def test_author_email(self):
         tip = self.repo.get_changeset()
-        self.assertEqual(tip.author_email, u'[e-mail]')
+        assert tip.author_email == u'[e-mail]'
 
     def test_get_changesets_raise_changesetdoesnotexist_for_wrong_start(self):
-        with self.assertRaises(ChangesetDoesNotExistError):
+        with pytest.raises(ChangesetDoesNotExistError):
             list(self.repo.get_changesets(start='foobar'))
 
     def test_get_changesets_raise_changesetdoesnotexist_for_wrong_end(self):
-        with self.assertRaises(ChangesetDoesNotExistError):
+        with pytest.raises(ChangesetDoesNotExistError):
             list(self.repo.get_changesets(end='foobar'))
 
     def test_get_changesets_raise_branchdoesnotexist_for_wrong_branch_name(self):
-        with self.assertRaises(BranchDoesNotExistError):
+        with pytest.raises(BranchDoesNotExistError):
             list(self.repo.get_changesets(branch_name='foobar'))
 
     def test_get_changesets_raise_repositoryerror_for_wrong_start_end(self):
         start = self.repo.revisions[-1]
         end = self.repo.revisions[0]
-        with self.assertRaises(RepositoryError):
+        with pytest.raises(RepositoryError):
             list(self.repo.get_changesets(start=start, end=end))
 
     def test_get_changesets_numerical_id_reversed(self):
-        with self.assertRaises(RepositoryError):
+        with pytest.raises(RepositoryError):
             [x for x in self.repo.get_changesets(start=3, end=2)]
 
     def test_get_changesets_numerical_id_respects_both_start_and_end_last(self):
-        with self.assertRaises(RepositoryError):
+        with pytest.raises(RepositoryError):
             last = len(self.repo.revisions)
             list(self.repo.get_changesets(start=last-1, end=last-2))
 
     def test_get_changesets_numerical_id_last_zero_error(self):
-        with self.assertRaises(RepositoryError):
+        with pytest.raises(RepositoryError):
             last = len(self.repo.revisions)
             list(self.repo.get_changesets(start=last-1, end=0))
 
 
 class _ChangesetsChangesTestCaseMixin(_BackendTestMixin):
     recreate_repo_per_test = False
 
     @classmethod
     def _get_commits(cls):
         return [
             {
                 'message': u'Initial',
                 'author': u'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foo/bar', content='foo'),
                     FileNode('foo/bał', content='foo'),
                     FileNode('foobar', content='foo'),
                     FileNode('qwe', content='foo'),
                 ],
             },
             {
                 'message': u'Massive changes',
                 'author': u'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'added': [FileNode('fallout', content='War never changes')],
                 'changed': [
                     FileNode('foo/bar', content='baz'),
                     FileNode('foobar', content='baz'),
                 ],
                 'removed': [FileNode('qwe')],
             },
         ]
 
     def test_initial_commit(self):
         changeset = self.repo.get_changeset(0)
-        self.assertItemsEqual(changeset.added, [
+        assert sorted(list(changeset.added)) == sorted([
             changeset.get_node('foo/bar'),
             changeset.get_node('foo/bał'),
             changeset.get_node('foobar'),
             changeset.get_node('qwe'),
         ])
-        self.assertItemsEqual(changeset.changed, [])
-        self.assertItemsEqual(changeset.removed, [])
+        assert list(changeset.changed) == []
+        assert list(changeset.removed) == []
         assert u'foo/ba\u0142' in changeset.as_dict()['added']
         assert u'foo/ba\u0142' in changeset.__json__(with_file_list=True)['added']
 
     def test_head_added(self):
         changeset = self.repo.get_changeset()
-        self.assertTrue(isinstance(changeset.added, AddedFileNodesGenerator))
-        self.assertItemsEqual(changeset.added, [
+        assert isinstance(changeset.added, AddedFileNodesGenerator)
+        assert list(changeset.added) == [
             changeset.get_node('fallout'),
-        ])
-        self.assertTrue(isinstance(changeset.changed, ChangedFileNodesGenerator))
-        self.assertItemsEqual(changeset.changed, [
+        ]
+        assert isinstance(changeset.changed, ChangedFileNodesGenerator)
+        assert list(changeset.changed) == [
             changeset.get_node('foo/bar'),
             changeset.get_node('foobar'),
-        ])
-        self.assertTrue(isinstance(changeset.removed, RemovedFileNodesGenerator))
-        self.assertEqual(len(changeset.removed), 1)
-        self.assertEqual(list(changeset.removed)[0].path, 'qwe')
+        ]
+        assert isinstance(changeset.removed, RemovedFileNodesGenerator)
+        assert len(changeset.removed) == 1
+        assert list(changeset.removed)[0].path == 'qwe'
 
     def test_get_filemode(self):
         changeset = self.repo.get_changeset()
-        self.assertEqual(33188, changeset.get_file_mode('foo/bar'))
+        assert 33188 == changeset.get_file_mode('foo/bar')
 
     def test_get_filemode_non_ascii(self):
         changeset = self.repo.get_changeset()
-        self.assertEqual(33188, changeset.get_file_mode('foo/bał'))
-        self.assertEqual(33188, changeset.get_file_mode(u'foo/bał'))
+        assert 33188 == changeset.get_file_mode('foo/bał')
+        assert 33188 == changeset.get_file_mode(u'foo/bał')
 
 
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
     # tests with additional commits
-    cls_name = alias.title() + 'ChangesetsWithCommitsTest'
-    bases = (_ChangesetsWithCommitsTestCaseixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = 'Test' + alias.title() + 'ChangesetsWithCommits'
+    globals()[cls_name] = type(cls_name, (_ChangesetsWithCommitsTestCaseixin,), attrs)
 
     # tests without additional commits
-    cls_name = alias.title() + 'ChangesetsTest'
-    bases = (_ChangesetsTestCaseMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = 'Test' + alias.title() + 'Changesets'
+    globals()[cls_name] = type(cls_name, (_ChangesetsTestCaseMixin,), attrs)
 
     # tests changes
-    cls_name = alias.title() + 'ChangesetsChangesTest'
-    bases = (_ChangesetsChangesTestCaseMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = 'Test' + alias.title() + 'ChangesetsChanges'
+    globals()[cls_name] = type(cls_name, (_ChangesetsChangesTestCaseMixin,), attrs)

kallithea/tests/vcs/test_filenodes_unicode_path.py

@@ -1,43 +1,43 b''
 # encoding: utf8
 
 import datetime
 
 from kallithea.lib.vcs.nodes import FileNode
 from kallithea.tests.vcs.test_inmemchangesets import BackendBaseTestCase
 from kallithea.tests.vcs.conf import SCM_TESTS
 
 
 class FileNodeUnicodePathTestsMixin(object):
 
     fname = 'ąśðąęłąć.txt'
     ufname = (fname).decode('utf-8')
 
     def get_commits(self):
         self.nodes = [
             FileNode(self.fname, content='Foobar'),
         ]
 
         commits = [
             {
                 'message': 'Initial commit',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': self.nodes,
             },
         ]
         return commits
 
     def test_filenode_path(self):
         node = self.tip.get_node(self.fname)
         unode = self.tip.get_node(self.ufname)
-        self.assertEqual(node, unode)
+        assert node == unode
 
 
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
-    cls_name = ''.join(('%s file node unicode path test' % alias).title()
+    cls_name = ''.join(('test %s file node unicode path' % alias).title()
         .split())
     bases = (FileNodeUnicodePathTestsMixin, BackendBaseTestCase)
     globals()[cls_name] = type(cls_name, bases, attrs)

kallithea/tests/vcs/test_getitem.py

@@ -1,39 +1,37 b''
 import datetime
 
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS
 from kallithea.lib.vcs.nodes import FileNode
-from kallithea.lib.vcs.utils.compat import unittest
 
 
 class GetitemTestCaseMixin(_BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': 'Commit %d' % x,
                 'author': 'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
             }
 
     def test__getitem__last_item_is_tip(self):
-        self.assertEqual(self.repo[-1], self.repo.get_changeset())
+        assert self.repo[-1] == self.repo.get_changeset()
 
     def test__getitem__returns_correct_items(self):
         changesets = [self.repo[x] for x in xrange(len(self.repo.revisions))]
-        self.assertEqual(changesets, list(self.repo.get_changesets()))
+        assert changesets == list(self.repo.get_changesets())
 
 
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
-    cls_name = ''.join(('%s getitem test' % alias).title().split())
-    bases = (GetitemTestCaseMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = ''.join(('test %s getitem' % alias).title().split())
+    globals()[cls_name] = type(cls_name, (GetitemTestCaseMixin,), attrs)

kallithea/tests/vcs/test_getslice.py

@@ -1,53 +1,46 b''
 import datetime
 
 from kallithea.lib.vcs.nodes import FileNode
 
-from kallithea.lib.vcs.utils.compat import unittest
-
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS
 
 
 class GetsliceTestCaseMixin(_BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': 'Commit %d' % x,
                 'author': 'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
             }
 
     def test__getslice__last_item_is_tip(self):
-        self.assertEqual(list(self.repo[-1:])[0], self.repo.get_changeset())
+        assert list(self.repo[-1:])[0] == self.repo.get_changeset()
 
     def test__getslice__respects_start_index(self):
-        self.assertEqual(list(self.repo[2:]),
-            [self.repo.get_changeset(rev) for rev in self.repo.revisions[2:]])
+        assert list(self.repo[2:]) == [self.repo.get_changeset(rev) for rev in self.repo.revisions[2:]]
 
     def test__getslice__respects_negative_start_index(self):
-        self.assertEqual(list(self.repo[-2:]),
-            [self.repo.get_changeset(rev) for rev in self.repo.revisions[-2:]])
+        assert list(self.repo[-2:]) == [self.repo.get_changeset(rev) for rev in self.repo.revisions[-2:]]
 
     def test__getslice__respects_end_index(self):
-        self.assertEqual(list(self.repo[:2]),
-            [self.repo.get_changeset(rev) for rev in self.repo.revisions[:2]])
+        assert list(self.repo[:2]) == [self.repo.get_changeset(rev) for rev in self.repo.revisions[:2]]
 
     def test__getslice__respects_negative_end_index(self):
-        self.assertEqual(list(self.repo[:-2]),
-            [self.repo.get_changeset(rev) for rev in self.repo.revisions[:-2]])
+        assert list(self.repo[:-2]) == [self.repo.get_changeset(rev) for rev in self.repo.revisions[:-2]]
 
 
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
-    cls_name = ''.join(('%s getslice test' % alias).title().split())
-    bases = (GetsliceTestCaseMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = ''.join(('test %s getslice' % alias).title().split())
+    globals()[cls_name] = type(cls_name, (GetsliceTestCaseMixin,), attrs)

kallithea/tests/vcs/test_git.py

@@ -1,847 +1,828 b''
 import os
 import sys
 import mock
 import datetime
 import urllib2
 
 import pytest
 
 from kallithea.lib.vcs.backends.git import GitRepository, GitChangeset
 from kallithea.lib.vcs.exceptions import RepositoryError, VCSError, NodeDoesNotExistError
 from kallithea.lib.vcs.nodes import NodeKind, FileNode, DirNode, NodeState
-from kallithea.lib.vcs.utils.compat import unittest
 from kallithea.model.scm import ScmModel
 
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import TEST_GIT_REPO, TEST_GIT_REPO_CLONE, TESTS_TMP_PATH, get_new_dir
 
 
-class GitRepositoryTest(unittest.TestCase):
+class TestGitRepository(object):
 
     def __check_for_existing_repo(self):
         if os.path.exists(TEST_GIT_REPO_CLONE):
             pytest.fail('Cannot test git clone repo as location %s already '
                       'exists. You should manually remove it first.'
                       % TEST_GIT_REPO_CLONE)
 
-    def setUp(self):
+    def setup_method(self):
         self.repo = GitRepository(TEST_GIT_REPO)
 
     def test_wrong_repo_path(self):
         wrong_repo_path = os.path.join(TESTS_TMP_PATH, 'errorrepo')
-        self.assertRaises(RepositoryError, GitRepository, wrong_repo_path)
+        with pytest.raises(RepositoryError):
+            GitRepository(wrong_repo_path)
 
     def test_git_cmd_injection(self):
         repo_inject_path = TEST_GIT_REPO + '; echo "Cake";'
-        with self.assertRaises(urllib2.URLError):
+        with pytest.raises(urllib2.URLError):
             # Should fail because URL will contain the parts after ; too
             GitRepository(get_new_dir('injection-repo'), src_url=repo_inject_path, update_after_clone=True, create=True)
 
-        with self.assertRaises(RepositoryError):
+        with pytest.raises(RepositoryError):
             # Should fail on direct clone call, which as of this writing does not happen outside of class
             clone_fail_repo = GitRepository(get_new_dir('injection-repo'), create=True)
             clone_fail_repo.clone(repo_inject_path, update_after_clone=True,)
 
         # Verify correct quoting of evil characters that should work on posix file systems
         if sys.platform == 'win32':
             # windows does not allow '"' in dir names
             # and some versions of the git client don't like ` and '
             tricky_path = get_new_dir("tricky-path-repo-$")
         else:
             tricky_path = get_new_dir("tricky-path-repo-$'\"`")
         successfully_cloned = GitRepository(tricky_path, src_url=TEST_GIT_REPO, update_after_clone=True, create=True)
         # Repo should have been created
-        self.assertFalse(successfully_cloned._repo.bare)
+        assert not successfully_cloned._repo.bare
 
         if sys.platform == 'win32':
             # windows does not allow '"' in dir names
             # and some versions of the git client don't like ` and '
             tricky_path_2 = get_new_dir("tricky-path-2-repo-$")
         else:
             tricky_path_2 = get_new_dir("tricky-path-2-repo-$'\"`")
         successfully_cloned2 = GitRepository(tricky_path_2, src_url=tricky_path, bare=True, create=True)
         # Repo should have been created and thus used correct quoting for clone
-        self.assertTrue(successfully_cloned2._repo.bare)
+        assert successfully_cloned2._repo.bare
 
         # Should pass because URL has been properly quoted
         successfully_cloned.pull(tricky_path_2)
         successfully_cloned2.fetch(tricky_path)
 
     def test_repo_create_with_spaces_in_path(self):
         repo_path = get_new_dir("path with spaces")
         repo = GitRepository(repo_path, src_url=None, bare=True, create=True)
         # Repo should have been created
-        self.assertTrue(repo._repo.bare)
+        assert repo._repo.bare
 
     def test_repo_clone(self):
         self.__check_for_existing_repo()
         repo = GitRepository(TEST_GIT_REPO)
         repo_clone = GitRepository(TEST_GIT_REPO_CLONE,
             src_url=TEST_GIT_REPO, create=True, 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_spaces_in_path(self):
         repo_path = get_new_dir("path with spaces")
         successfully_cloned = GitRepository(repo_path, src_url=TEST_GIT_REPO, update_after_clone=True, create=True)
         # Repo should have been created
-        self.assertFalse(successfully_cloned._repo.bare)
+        assert not successfully_cloned._repo.bare
 
         successfully_cloned.pull(TEST_GIT_REPO)
         self.repo.fetch(repo_path)
 
     def test_repo_clone_without_create(self):
-        self.assertRaises(RepositoryError, GitRepository,
-            TEST_GIT_REPO_CLONE + '_wo_create', src_url=TEST_GIT_REPO)
+        with pytest.raises(RepositoryError):
+            GitRepository(TEST_GIT_REPO_CLONE + '_wo_create', src_url=TEST_GIT_REPO)
 
     def test_repo_clone_with_update(self):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = TEST_GIT_REPO_CLONE + '_with_update'
         repo_clone = GitRepository(clone_path,
             create=True, src_url=TEST_GIT_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
         fpath = os.path.join(clone_path, 'MANIFEST.in')
-        self.assertEqual(True, os.path.isfile(fpath),
-            'Repo was cloned and updated but file %s could not be found'
-            % fpath)
+        assert os.path.isfile(fpath) == True, 'Repo was cloned and updated but file %s could not be found' % fpath
 
     def test_repo_clone_without_update(self):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = TEST_GIT_REPO_CLONE + '_without_update'
         repo_clone = GitRepository(clone_path,
             create=True, src_url=TEST_GIT_REPO, update_after_clone=False)
-        self.assertEqual(len(repo.revisions), len(repo_clone.revisions))
+        assert len(repo.revisions) == len(repo_clone.revisions)
         # check if current workdir was *NOT* updated
         fpath = os.path.join(clone_path, 'MANIFEST.in')
         # Make sure it's not bare repo
-        self.assertFalse(repo_clone._repo.bare)
-        self.assertEqual(False, os.path.isfile(fpath),
-            'Repo was cloned and updated but file %s was found'
-            % fpath)
+        assert not repo_clone._repo.bare
+        assert os.path.isfile(fpath) == False, 'Repo was cloned and updated but file %s was found' % fpath
 
     def test_repo_clone_into_bare_repo(self):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = TEST_GIT_REPO_CLONE + '_bare.git'
         repo_clone = GitRepository(clone_path, create=True,
             src_url=repo.path, bare=True)
-        self.assertTrue(repo_clone._repo.bare)
+        assert repo_clone._repo.bare
 
     def test_create_repo_is_not_bare_by_default(self):
         repo = GitRepository(get_new_dir('not-bare-by-default'), create=True)
-        self.assertFalse(repo._repo.bare)
+        assert not repo._repo.bare
 
     def test_create_bare_repo(self):
         repo = GitRepository(get_new_dir('bare-repo'), create=True, bare=True)
-        self.assertTrue(repo._repo.bare)
+        assert repo._repo.bare
 
     def test_revisions(self):
         # there are 112 revisions (by now)
         # so we can assume they would be available from now on
         subset = set([
             'c1214f7e79e02fc37156ff215cd71275450cffc3',
             '38b5fe81f109cb111f549bfe9bb6b267e10bc557',
             'fa6600f6848800641328adbf7811fd2372c02ab2',
             '102607b09cdd60e2793929c4f90478be29f85a17',
             '49d3fd156b6f7db46313fac355dca1a0b94a0017',
             '2d1028c054665b962fa3d307adfc923ddd528038',
             'd7e0d30fbcae12c90680eb095a4f5f02505ce501',
             'ff7ca51e58c505fec0dd2491de52c622bb7a806b',
             'dd80b0f6cf5052f17cc738c2951c4f2070200d7f',
             '8430a588b43b5d6da365400117c89400326e7992',
             'd955cd312c17b02143c04fa1099a352b04368118',
             'f67b87e5c629c2ee0ba58f85197e423ff28d735b',
             'add63e382e4aabc9e1afdc4bdc24506c269b7618',
             'f298fe1189f1b69779a4423f40b48edf92a703fc',
             'bd9b619eb41994cac43d67cf4ccc8399c1125808',
             '6e125e7c890379446e98980d8ed60fba87d0f6d1',
             'd4a54db9f745dfeba6933bf5b1e79e15d0af20bd',
             '0b05e4ed56c802098dfc813cbe779b2f49e92500',
             '191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
             '45223f8f114c64bf4d6f853e3c35a369a6305520',
             'ca1eb7957a54bce53b12d1a51b13452f95bc7c7e',
             'f5ea29fc42ef67a2a5a7aecff10e1566699acd68',
             '27d48942240f5b91dfda77accd2caac94708cc7d',
             '622f0eb0bafd619d2560c26f80f09e3b0b0d78af',
             'e686b958768ee96af8029fe19c6050b1a8dd3b2b'])
-        self.assertTrue(subset.issubset(set(self.repo.revisions)))
+        assert subset.issubset(set(self.repo.revisions))
 
     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
         # Removed (those are 'remotes' branches for cloned repo)
-        #self.assertTrue('master' in self.repo.branches)
-        #self.assertTrue('gittree' in self.repo.branches)
-        #self.assertTrue('web-branch' in self.repo.branches)
+        #assert 'master' in self.repo.branches
+        #assert 'gittree' in self.repo.branches
+        #assert 'web-branch' in self.repo.branches
         for name, id in self.repo.branches.items():
-            self.assertTrue(isinstance(
-                self.repo.get_changeset(id), GitChangeset))
+            assert isinstance(self.repo.get_changeset(id), GitChangeset)
 
     def test_tags(self):
         # TODO: Need more tests here
-        self.assertTrue('v0.1.1' in self.repo.tags)
-        self.assertTrue('v0.1.2' in self.repo.tags)
+        assert 'v0.1.1' in self.repo.tags
+        assert 'v0.1.2' in self.repo.tags
         for name, id in self.repo.tags.items():
-            self.assertTrue(isinstance(
-                self.repo.get_changeset(id), GitChangeset))
+            assert isinstance(self.repo.get_changeset(id), GitChangeset)
 
     def _test_single_changeset_cache(self, revision):
         chset = self.repo.get_changeset(revision)
-        self.assertTrue(revision in self.repo.changesets)
-        self.assertTrue(chset is self.repo.changesets[revision])
+        assert revision in self.repo.changesets
+        assert chset is self.repo.changesets[revision]
 
     def test_initial_changeset(self):
         id = self.repo.revisions[0]
         init_chset = self.repo.get_changeset(id)
-        self.assertEqual(init_chset.message, 'initial import\n')
-        self.assertEqual(init_chset.author,
-            'Marcin Kuzminski <[e-mail]>')
+        assert init_chset.message == 'initial import\n'
+        assert init_chset.author == 'Marcin Kuzminski <[e-mail]>'
         for path in ('vcs/__init__.py',
                      'vcs/backends/BaseRepository.py',
                      'vcs/backends/__init__.py'):
-            self.assertTrue(isinstance(init_chset.get_node(path), FileNode))
+            assert isinstance(init_chset.get_node(path), FileNode)
         for path in ('', 'vcs', 'vcs/backends'):
-            self.assertTrue(isinstance(init_chset.get_node(path), DirNode))
+            assert isinstance(init_chset.get_node(path), DirNode)
 
-        self.assertRaises(NodeDoesNotExistError, init_chset.get_node, path='foobar')
+        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):
-        self.assertRaises(RepositoryError, self.repo.get_changeset,
-            'f' * 40)
+        with pytest.raises(RepositoryError):
+            self.repo.get_changeset('f' * 40)
 
     def test_changeset10(self):
 
         chset10 = self.repo.get_changeset(self.repo.revisions[9])
         readme = """===
 VCS
 ===
 
 Various Version Control System management abstraction layer for Python.
 
 Introduction
 ------------
 
 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 GitChangesetTest(unittest.TestCase):
+class TestGitChangeset(object):
 
-    def setUp(self):
+    def setup_method(self):
         self.repo = GitRepository(TEST_GIT_REPO)
 
     def test_default_changeset(self):
         tip = self.repo.get_changeset()
-        self.assertEqual(tip, self.repo.get_changeset(None))
-        self.assertEqual(tip, self.repo.get_changeset('tip'))
+        assert tip == self.repo.get_changeset(None)
+        assert tip == self.repo.get_changeset('tip')
 
     def test_root_node(self):
         tip = self.repo.get_changeset()
-        self.assertTrue(tip.root is tip.get_node(''))
+        assert tip.root is tip.get_node('')
 
     def test_lazy_fetch(self):
         """
         Test if changeset's nodes expands and are cached as we walk through
         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.
         """
         commit_id = '2a13f185e4525f9d4b59882791a2d397b90d5ddc'
-        self.assertTrue(commit_id in self.repo.revisions)
+        assert commit_id in self.repo.revisions
         chset = self.repo.get_changeset(commit_id)
-        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):
         commit_id = '2a13f185e4525f9d4b59882791a2d397b90d5ddc'
         chset = self.repo.get_changeset(commit_id)
         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):
         """
         rev0 = self.repo.revisions[0]
         chset0 = self.repo.get_changeset(rev0)
-        self.assertEqual(chset0.branch, 'master')
-        self.assertEqual(chset0.tags, [])
+        assert chset0.branch == 'master'
+        assert chset0.tags == []
 
         rev10 = self.repo.revisions[10]
         chset10 = self.repo.get_changeset(rev10)
-        self.assertEqual(chset10.branch, 'master')
-        self.assertEqual(chset10.tags, [])
+        assert chset10.branch == 'master'
+        assert chset10.tags == []
 
         rev44 = self.repo.revisions[44]
         chset44 = self.repo.get_changeset(rev44)
-        self.assertEqual(chset44.branch, 'web-branch')
+        assert chset44.branch == 'web-branch'
 
         tip = self.repo.get_changeset('tip')
-        self.assertTrue('tip' in tip.tags)
+        assert 'tip' in tip.tags
         """
         # Those tests would fail - branches are now going
         # to be changed at main API in order to support git backend
         pass
 
     def _test_slices(self, limit, offset):
         count = self.repo.count()
         changesets = self.repo.get_changesets(limit=limit, offset=offset)
         idx = 0
         for changeset in changesets:
             rev = offset + idx
             idx += 1
             rev_id = self.repo.revisions[rev]
             if idx > limit:
                 pytest.fail("Exceeded limit already (getting revision %s, "
                     "there are %s total revisions, offset=%s, limit=%s)"
                     % (rev_id, count, offset, limit))
-            self.assertEqual(changeset, self.repo.get_changeset(rev_id))
+            assert changeset == self.repo.get_changeset(rev_id)
         result = list(self.repo.get_changesets(limit=limit, offset=offset))
         start = offset
         end = limit and offset + limit or None
         sliced = list(self.repo[start:end])
         pytest.failUnlessEqual(result, sliced,
             msg="Comparison failed for limit=%s, offset=%s"
             "(get_changeset returned: %s and sliced: %s"
             % (limit, offset, result, sliced))
 
     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 = (
             ('c1214f7e79e02fc37156ff215cd71275450cffc3',
                 'vcs/backends/BaseRepository.py', 502),
             ('d7e0d30fbcae12c90680eb095a4f5f02505ce501',
                 'vcs/backends/hg.py', 854),
             ('6e125e7c890379446e98980d8ed60fba87d0f6d1',
                 'setup.py', 1068),
             ('d955cd312c17b02143c04fa1099a352b04368118',
                 'vcs/backends/base.py', 2921),
             ('ca1eb7957a54bce53b12d1a51b13452f95bc7c7e',
                 'vcs/backends/base.py', 3936),
             ('f50f42baeed5af6518ef4b0cb2f1423f3851a941',
                 'vcs/backends/base.py', 6189),
         )
         for revision, path, size in to_check:
             self._test_file_size(revision, path, size)
 
     def _test_dir_size(self, revision, path, size):
         node = self.repo.get_changeset(revision).get_node(path)
-        self.assertEqual(node.size, size)
+        assert node.size == size
 
     def test_dir_size(self):
         to_check = (
             ('5f2c6ee195929b0be80749243c18121c9864a3b3', '/', 674076),
             ('7ab37bc680b4aa72c34d07b230c866c28e9fc204', '/', 674049),
             ('6892503fb8f2a552cef5f4d4cc2cdbd13ae1cd2f', '/', 671830),
         )
         for revision, path, size in to_check:
             self._test_dir_size(revision, path, size)
 
     def test_repo_size(self):
-        self.assertEqual(self.repo.size, 674076)
+        assert self.repo.size == 674076
 
     def test_file_history(self):
         # we can only check if those revisions are present in the history
         # as we cannot update this test every time file is changed
         files = {
             'setup.py': [
                 '54386793436c938cff89326944d4c2702340037d',
                 '51d254f0ecf5df2ce50c0b115741f4cf13985dab',
                 '998ed409c795fec2012b1c0ca054d99888b22090',
                 '5e0eb4c47f56564395f76333f319d26c79e2fb09',
                 '0115510b70c7229dbc5dc49036b32e7d91d23acd',
                 '7cb3fd1b6d8c20ba89e2264f1c8baebc8a52d36e',
                 '2a13f185e4525f9d4b59882791a2d397b90d5ddc',
                 '191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b',
             ],
             'vcs/nodes.py': [
                 '33fa3223355104431402a888fa77a4e9956feb3e',
                 'fa014c12c26d10ba682fadb78f2a11c24c8118e1',
                 'e686b958768ee96af8029fe19c6050b1a8dd3b2b',
                 'ab5721ca0a081f26bf43d9051e615af2cc99952f',
                 'c877b68d18e792a66b7f4c529ea02c8f80801542',
                 '4313566d2e417cb382948f8d9d7c765330356054',
                 '6c2303a793671e807d1cfc70134c9ca0767d98c2',
                 '54386793436c938cff89326944d4c2702340037d',
                 '54000345d2e78b03a99d561399e8e548de3f3203',
                 '1c6b3677b37ea064cb4b51714d8f7498f93f4b2b',
                 '2d03ca750a44440fb5ea8b751176d1f36f8e8f46',
                 '2a08b128c206db48c2f0b8f70df060e6db0ae4f8',
                 '30c26513ff1eb8e5ce0e1c6b477ee5dc50e2f34b',
                 'ac71e9503c2ca95542839af0ce7b64011b72ea7c',
                 '12669288fd13adba2a9b7dd5b870cc23ffab92d2',
                 '5a0c84f3e6fe3473e4c8427199d5a6fc71a9b382',
                 '12f2f5e2b38e6ff3fbdb5d722efed9aa72ecb0d5',
                 '5eab1222a7cd4bfcbabc218ca6d04276d4e27378',
                 'f50f42baeed5af6518ef4b0cb2f1423f3851a941',
                 'd7e390a45f6aa96f04f5e7f583ad4f867431aa25',
                 'f15c21f97864b4f071cddfbf2750ec2e23859414',
                 'e906ef056cf539a4e4e5fc8003eaf7cf14dd8ade',
                 'ea2b108b48aa8f8c9c4a941f66c1a03315ca1c3b',
                 '84dec09632a4458f79f50ddbbd155506c460b4f9',
                 '0115510b70c7229dbc5dc49036b32e7d91d23acd',
                 '2a13f185e4525f9d4b59882791a2d397b90d5ddc',
                 '3bf1c5868e570e39569d094f922d33ced2fa3b2b',
                 'b8d04012574729d2c29886e53b1a43ef16dd00a1',
                 '6970b057cffe4aab0a792aa634c89f4bebf01441',
                 'dd80b0f6cf5052f17cc738c2951c4f2070200d7f',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b',
             ],
             'vcs/backends/git.py': [
                 '4cf116ad5a457530381135e2f4c453e68a1b0105',
                 '9a751d84d8e9408e736329767387f41b36935153',
                 'cb681fb539c3faaedbcdf5ca71ca413425c18f01',
                 '428f81bb652bcba8d631bce926e8834ff49bdcc6',
                 '180ab15aebf26f98f714d8c68715e0f05fa6e1c7',
                 '2b8e07312a2e89e92b90426ab97f349f4bce2a3a',
                 '50e08c506174d8645a4bb517dd122ac946a0f3bf',
                 '54000345d2e78b03a99d561399e8e548de3f3203',
             ],
         }
         for path, revs in files.items():
             node = self.repo.get_changeset(revs[0]).get_node(path)
             node_revs = [chset.raw_id 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 = {
             'vcs/backends/__init__.py': {
                 'c1214f7e79e02fc37156ff215cd71275450cffc3': {
                     'lines_no': 1,
                     'changesets': [
                         'c1214f7e79e02fc37156ff215cd71275450cffc3',
                     ],
                 },
                 '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647': {
                     'lines_no': 21,
                     'changesets': [
                         '49d3fd156b6f7db46313fac355dca1a0b94a0017',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                     ],
                 },
                 'e29b67bd158580fc90fc5e9111240b90e6e86064': {
                     'lines_no': 32,
                     'changesets': [
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '5eab1222a7cd4bfcbabc218ca6d04276d4e27378',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '54000345d2e78b03a99d561399e8e548de3f3203',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '78c3f0c23b7ee935ec276acb8b8212444c33c396',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '2a13f185e4525f9d4b59882791a2d397b90d5ddc',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '78c3f0c23b7ee935ec276acb8b8212444c33c396',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                     ],
                 },
             },
         }
 
         for fname, revision_dict in files.items():
             for rev, data in revision_dict.items():
                 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_1
                 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_files_state(self):
         """
         Tests state of FileNodes.
         """
         node = self.repo \
             .get_changeset('e6ea6d16e2f26250124a1f4b4fe37a912f9d86a0') \
             .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
 
         node = self.repo \
             .get_changeset('33fa3223355104431402a888fa77a4e9956feb3e') \
             .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
 
         node = self.repo \
             .get_changeset('e29b67bd158580fc90fc5e9111240b90e6e86064') \
             .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(
             'fa6600f6848800641328adbf7811fd2372c02ab2')
         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]
 
         chset = self.repo.get_changeset(
             '54386793436c938cff89326944d4c2702340037d')
         changed = ['setup.py', 'tests/test_nodes.py', 'vcs/backends/hg.py',
             'vcs/nodes.py']
-        self.assertEqual(set(changed), set([f.path for f in chset.changed]))
+        assert set(changed) == set([f.path for f in chset.changed])
 
     def test_commit_message_is_unicode(self):
         for cs in self.repo:
-            self.assertEqual(type(cs.message), unicode)
+            assert type(cs.message) == unicode
 
     def test_changeset_author_is_unicode(self):
         for cs in self.repo:
-            self.assertEqual(type(cs.author), unicode)
+            assert type(cs.author) == unicode
 
     def test_repo_files_content_is_unicode(self):
         changeset = self.repo.get_changeset()
         for node in 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'
         tip = self.repo.get_changeset()
-        self.assertRaises(VCSError, tip.get_node, path)
+        with pytest.raises(VCSError):
+            tip.get_node(path)
 
     def test_author_email(self):
-        self.assertEqual('[e-mail]',
-          self.repo.get_changeset('c1214f7e79e02fc37156ff215cd71275450cffc3') \
-          .author_email)
-        self.assertEqual('[e-mail]',
-          self.repo.get_changeset('ff7ca51e58c505fec0dd2491de52c622bb7a806b') \
-          .author_email)
-        self.assertEqual('',
-          self.repo.get_changeset('8430a588b43b5d6da365400117c89400326e7992') \
-          .author_email)
+        assert '[e-mail]' == self.repo.get_changeset('c1214f7e79e02fc37156ff215cd71275450cffc3').author_email
+        assert '[e-mail]' == self.repo.get_changeset('ff7ca51e58c505fec0dd2491de52c622bb7a806b').author_email
+        assert '' == self.repo.get_changeset('8430a588b43b5d6da365400117c89400326e7992').author_email
 
     def test_author_username(self):
-        self.assertEqual('Marcin Kuzminski',
-          self.repo.get_changeset('c1214f7e79e02fc37156ff215cd71275450cffc3') \
-          .author_name)
-        self.assertEqual('Lukasz Balcerzak',
-          self.repo.get_changeset('ff7ca51e58c505fec0dd2491de52c622bb7a806b') \
-          .author_name)
-        self.assertEqual('marcink none@none',
-          self.repo.get_changeset('8430a588b43b5d6da365400117c89400326e7992') \
-          .author_name)
+        assert 'Marcin Kuzminski' == self.repo.get_changeset('c1214f7e79e02fc37156ff215cd71275450cffc3').author_name
+        assert 'Lukasz Balcerzak' == self.repo.get_changeset('ff7ca51e58c505fec0dd2491de52c622bb7a806b').author_name
+        assert 'marcink none@none' == self.repo.get_changeset('8430a588b43b5d6da365400117c89400326e7992').author_name
 
 
-class GitSpecificTest(unittest.TestCase):
+class TestGitSpecific():
 
     def test_error_is_raised_for_added_if_diff_name_status_is_wrong(self):
         repo = mock.MagicMock()
         changeset = GitChangeset(repo, 'foobar')
         changeset._diff_name_status = 'foobar'
-        with self.assertRaises(VCSError):
+        with pytest.raises(VCSError):
             changeset.added
 
     def test_error_is_raised_for_changed_if_diff_name_status_is_wrong(self):
         repo = mock.MagicMock()
         changeset = GitChangeset(repo, 'foobar')
         changeset._diff_name_status = 'foobar'
-        with self.assertRaises(VCSError):
+        with pytest.raises(VCSError):
             changeset.added
 
     def test_error_is_raised_for_removed_if_diff_name_status_is_wrong(self):
         repo = mock.MagicMock()
         changeset = GitChangeset(repo, 'foobar')
         changeset._diff_name_status = 'foobar'
-        with self.assertRaises(VCSError):
+        with pytest.raises(VCSError):
             changeset.added
 
 
-class GitSpecificWithRepoTest(_BackendTestMixin, unittest.TestCase):
+class TestGitSpecificWithRepo(_BackendTestMixin):
     backend_alias = 'git'
 
     @classmethod
     def _get_commits(cls):
         return [
             {
                 'message': 'Initial',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foobar/static/js/admin/base.js', content='base'),
                     FileNode('foobar/static/admin', content='admin',
                         mode=0120000), # this is a link
                     FileNode('foo', content='foo'),
                 ],
             },
             {
                 'message': 'Second',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'added': [
                     FileNode('foo2', content='foo2'),
                 ],
             },
         ]
 
     def test_paths_slow_traversing(self):
         cs = self.repo.get_changeset()
-        self.assertEqual(cs.get_node('foobar').get_node('static').get_node('js')
-            .get_node('admin').get_node('base.js').content, 'base')
+        assert cs.get_node('foobar').get_node('static').get_node('js').get_node('admin').get_node('base.js').content == 'base'
 
     def test_paths_fast_traversing(self):
         cs = self.repo.get_changeset()
-        self.assertEqual(cs.get_node('foobar/static/js/admin/base.js').content,
-            'base')
+        assert cs.get_node('foobar/static/js/admin/base.js').content == 'base'
 
     def test_workdir_get_branch(self):
         self.repo.run_git_command(['checkout', '-b', 'production'])
         # Regression test: one of following would fail if we don't check
         # .git/HEAD file
         self.repo.run_git_command(['checkout', 'production'])
-        self.assertEqual(self.repo.workdir.get_branch(), 'production')
+        assert self.repo.workdir.get_branch() == 'production'
         self.repo.run_git_command(['checkout', 'master'])
-        self.assertEqual(self.repo.workdir.get_branch(), 'master')
+        assert self.repo.workdir.get_branch() == 'master'
 
     def test_get_diff_runs_git_command_with_hashes(self):
         self.repo.run_git_command = mock.Mock(return_value=['', ''])
         self.repo.get_diff(0, 1)
         self.repo.run_git_command.assert_called_once_with(
             ['diff', '-U3', '--full-index', '--binary', '-p', '-M', '--abbrev=40',
              self.repo._get_revision(0), self.repo._get_revision(1)])
 
     def test_get_diff_runs_git_command_with_str_hashes(self):
         self.repo.run_git_command = mock.Mock(return_value=['', ''])
         self.repo.get_diff(self.repo.EMPTY_CHANGESET, 1)
         self.repo.run_git_command.assert_called_once_with(
             ['show', '-U3', '--full-index', '--binary', '-p', '-M', '--abbrev=40',
              self.repo._get_revision(1)])
 
     def test_get_diff_runs_git_command_with_path_if_its_given(self):
         self.repo.run_git_command = mock.Mock(return_value=['', ''])
         self.repo.get_diff(0, 1, 'foo')
         self.repo.run_git_command.assert_called_once_with(
             ['diff', '-U3', '--full-index', '--binary', '-p', '-M', '--abbrev=40',
              self.repo._get_revision(0), self.repo._get_revision(1), '--', 'foo'])
 
 
-class GitRegressionTest(_BackendTestMixin, unittest.TestCase):
+class TestGitRegression(_BackendTestMixin):
     backend_alias = 'git'
 
     @classmethod
     def _get_commits(cls):
         return [
             {
                 'message': 'Initial',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('bot/__init__.py', content='base'),
                     FileNode('bot/templates/404.html', content='base'),
                     FileNode('bot/templates/500.html', content='base'),
                 ],
             },
             {
                 'message': 'Second',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'added': [
                     FileNode('bot/build/migrations/1.py', content='foo2'),
                     FileNode('bot/build/migrations/2.py', content='foo2'),
                     FileNode('bot/build/static/templates/f.html', content='foo2'),
                     FileNode('bot/build/static/templates/f1.html', content='foo2'),
                     FileNode('bot/build/templates/err.html', content='foo2'),
                     FileNode('bot/build/templates/err2.html', content='foo2'),
                 ],
             },
         ]
 
     def test_similar_paths(self):
         cs = self.repo.get_changeset()
         paths = lambda *n: [x.path for x in n]
-        self.assertEqual(paths(*cs.get_nodes('bot')), ['bot/build', 'bot/templates', 'bot/__init__.py'])
-        self.assertEqual(paths(*cs.get_nodes('bot/build')), ['bot/build/migrations', 'bot/build/static', 'bot/build/templates'])
-        self.assertEqual(paths(*cs.get_nodes('bot/build/static')), ['bot/build/static/templates'])
+        assert paths(*cs.get_nodes('bot')) == ['bot/build', 'bot/templates', 'bot/__init__.py']
+        assert paths(*cs.get_nodes('bot/build')) == ['bot/build/migrations', 'bot/build/static', 'bot/build/templates']
+        assert paths(*cs.get_nodes('bot/build/static')) == ['bot/build/static/templates']
         # this get_nodes below causes troubles !
-        self.assertEqual(paths(*cs.get_nodes('bot/build/static/templates')), ['bot/build/static/templates/f.html', 'bot/build/static/templates/f1.html'])
-        self.assertEqual(paths(*cs.get_nodes('bot/build/templates')), ['bot/build/templates/err.html', 'bot/build/templates/err2.html'])
-        self.assertEqual(paths(*cs.get_nodes('bot/templates/')), ['bot/templates/404.html', 'bot/templates/500.html'])
+        assert paths(*cs.get_nodes('bot/build/static/templates')) == ['bot/build/static/templates/f.html', 'bot/build/static/templates/f1.html']
+        assert paths(*cs.get_nodes('bot/build/templates')) == ['bot/build/templates/err.html', 'bot/build/templates/err2.html']
+        assert paths(*cs.get_nodes('bot/templates/')) == ['bot/templates/404.html', 'bot/templates/500.html']
 
 
-class GitHooksTest(unittest.TestCase):
+class TestGitHooks(object):
     """
     Tests related to hook functionality of Git repositories.
     """
 
-    def setUp(self):
+    def setup_method(self):
         # For each run we want a fresh repo.
         self.repo_directory = get_new_dir("githookrepo")
         self.repo = GitRepository(self.repo_directory, create=True)
 
         # Create a dictionary where keys are hook names, and values are paths to
         # them. Deduplicates code in tests a bit.
         self.hook_directory = self.repo.get_hook_location()
         self.kallithea_hooks = dict((h, os.path.join(self.hook_directory, h)) for h in ("pre-receive", "post-receive"))
 
     def test_hooks_created_if_missing(self):
         """
         Tests if hooks are installed in repository if they are missing.
         """
 
         for hook, hook_path in self.kallithea_hooks.iteritems():
             if os.path.exists(hook_path):
                 os.remove(hook_path)
 
         ScmModel().install_git_hooks(repo=self.repo)
 
         for hook, hook_path in self.kallithea_hooks.iteritems():
-            self.assertTrue(os.path.exists(hook_path))
+            assert os.path.exists(hook_path)
 
     def test_kallithea_hooks_updated(self):
         """
         Tests if hooks are updated if they are Kallithea hooks already.
         """
 
         for hook, hook_path in self.kallithea_hooks.iteritems():
             with open(hook_path, "w") as f:
                 f.write("KALLITHEA_HOOK_VER=0.0.0\nJUST_BOGUS")
 
         ScmModel().install_git_hooks(repo=self.repo)
 
         for hook, hook_path in self.kallithea_hooks.iteritems():
             with open(hook_path) as f:
-                self.assertNotIn("JUST_BOGUS", f.read())
+                assert "JUST_BOGUS" not in f.read()
 
     def test_custom_hooks_untouched(self):
         """
         Tests if hooks are left untouched if they are not Kallithea hooks.
         """
 
         for hook, hook_path in self.kallithea_hooks.iteritems():
             with open(hook_path, "w") as f:
                 f.write("#!/bin/bash\n#CUSTOM_HOOK")
 
         ScmModel().install_git_hooks(repo=self.repo)
 
         for hook, hook_path in self.kallithea_hooks.iteritems():
             with open(hook_path) as f:
-                self.assertIn("CUSTOM_HOOK", f.read())
+                assert "CUSTOM_HOOK" in f.read()
 
     def test_custom_hooks_forced_update(self):
         """
         Tests if hooks are forcefully updated even though they are custom hooks.
         """
 
         for hook, hook_path in self.kallithea_hooks.iteritems():
             with open(hook_path, "w") as f:
                 f.write("#!/bin/bash\n#CUSTOM_HOOK")
 
         ScmModel().install_git_hooks(repo=self.repo, force_create=True)
 
         for hook, hook_path in self.kallithea_hooks.iteritems():
             with open(hook_path) as f:
-                self.assertIn("KALLITHEA_HOOK_VER", f.read())
+                assert "KALLITHEA_HOOK_VER" in f.read()

kallithea/tests/vcs/test_workdirs.py

@@ -1,95 +1,93 b''
 import datetime
 
-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 
 from kallithea.lib.vcs.nodes import FileNode
 
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS
 
 
 class WorkdirTestCaseMixin(_BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         commits = [
             {
                 'message': u'Initial commit',
                 'author': u'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foobar', content='Foobar'),
                     FileNode('foobar2', content='Foobar II'),
                     FileNode('foo/bar/baz', content='baz here!'),
                 ],
             },
             {
                 'message': u'Changes...',
                 'author': u'Jane Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 21),
                 'added': [
                     FileNode('some/new.txt', content='news...'),
                 ],
                 'changed': [
                     FileNode('foobar', 'Foobar I'),
                 ],
                 'removed': [],
             },
         ]
         return commits
 
     def test_get_branch_for_default_branch(self):
-        self.assertEqual(self.repo.workdir.get_branch(),
-            self.repo.DEFAULT_BRANCH_NAME)
+        assert self.repo.workdir.get_branch() == self.repo.DEFAULT_BRANCH_NAME
 
     def test_get_branch_after_adding_one(self):
         self.imc.add(FileNode('docs/index.txt',
             content='Documentation\n'))
         self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
         )
-        self.assertEqual(self.repo.workdir.get_branch(), self.default_branch)
+        assert self.repo.workdir.get_branch() == self.default_branch
 
     def test_get_changeset(self):
         old_head = self.repo.get_changeset()
         self.imc.add(FileNode('docs/index.txt',
             content='Documentation\n'))
         head = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
         )
-        self.assertEqual(self.repo.workdir.get_branch(), self.default_branch)
+        assert self.repo.workdir.get_branch() == self.default_branch
         self.repo.workdir.checkout_branch('foobar')
-        self.assertEqual(self.repo.workdir.get_changeset(), head)
+        assert self.repo.workdir.get_changeset() == head
 
         # Make sure that old head is still there after update to default branch
         self.repo.workdir.checkout_branch(self.default_branch)
-        self.assertEqual(self.repo.workdir.get_changeset(), old_head)
+        assert self.repo.workdir.get_changeset() == old_head
 
     def test_checkout_branch(self):
         from kallithea.lib.vcs.exceptions import BranchDoesNotExistError
         # first, 'foobranch' does not exist.
-        self.assertRaises(BranchDoesNotExistError, self.repo.workdir.checkout_branch,
-                          branch='foobranch')
+        with pytest.raises(BranchDoesNotExistError):
+            self.repo.workdir.checkout_branch(branch='foobranch')
         # create new branch 'foobranch'.
         self.imc.add(FileNode('file1', content='blah'))
         self.imc.commit(message=u'asd', author=u'john', branch='foobranch')
         # go back to the default branch
         self.repo.workdir.checkout_branch()
-        self.assertEqual(self.repo.workdir.get_branch(), self.backend_class.DEFAULT_BRANCH_NAME)
+        assert self.repo.workdir.get_branch() == self.backend_class.DEFAULT_BRANCH_NAME
         # checkout 'foobranch'
         self.repo.workdir.checkout_branch('foobranch')
-        self.assertEqual(self.repo.workdir.get_branch(), 'foobranch')
+        assert self.repo.workdir.get_branch() == 'foobranch'
 
 
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
-    cls_name = ''.join(('%s branch test' % alias).title().split())
-    bases = (WorkdirTestCaseMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = ''.join(('test %s branch' % alias).title().split())
+    globals()[cls_name] = type(cls_name, (WorkdirTestCaseMixin, ), attrs)