tests: convert remaining vcs tests to py.test

kallithea/tests/vcs/test_inmemchangesets.py

@@ -6,7 +6,7 b' Tests so called "in memory changesets" c'
 import time
 import datetime
 
-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 
 from kallithea.lib import vcs
 from kallithea.lib.vcs.exceptions import EmptyRepositoryError
@@ -38,7 +38,7 b' class InMemoryChangesetTestMixin(object)'
     def get_backend(self):
         return vcs.get_backend(self.backend_alias)
 
-    def setUp(self):
+    def setup_method(self):
         Backend = self.get_backend()
         self.repo_path = get_new_dir(str(time.time()))
         self.repo = Backend(self.repo_path, create=True)
@@ -62,14 +62,17 b' class InMemoryChangesetTestMixin(object)'
         changeset = self.imc.commit(message=message, author=author)
 
         newtip = self.repo.get_changeset()
-        self.assertEqual(changeset, newtip)
-        self.assertEqual(rev_count + 1, len(self.repo.revisions))
-        self.assertEqual(newtip.message, message)
-        self.assertEqual(newtip.author, author)
-        self.assertTrue(not any((self.imc.added, self.imc.changed,
-            self.imc.removed)))
+        assert changeset == newtip
+        assert rev_count + 1 == len(self.repo.revisions)
+        assert newtip.message == message
+        assert newtip.author == author
+        assert not any((
+            self.imc.added,
+            self.imc.changed,
+            self.imc.removed
+        ))
         for node in to_add:
-            self.assertEqual(newtip.get_node(node.path).content, node.content)
+            assert newtip.get_node(node.path).content == node.content
 
     def test_add_in_bulk(self):
         rev_count = len(self.repo.revisions)
@@ -81,23 +84,26 b' class InMemoryChangesetTestMixin(object)'
         changeset = self.imc.commit(message=message, author=author)
 
         newtip = self.repo.get_changeset()
-        self.assertEqual(changeset, newtip)
-        self.assertEqual(rev_count + 1, len(self.repo.revisions))
-        self.assertEqual(newtip.message, message)
-        self.assertEqual(newtip.author, author)
-        self.assertTrue(not any((self.imc.added, self.imc.changed,
-            self.imc.removed)))
+        assert changeset == newtip
+        assert rev_count + 1 == len(self.repo.revisions)
+        assert newtip.message == message
+        assert newtip.author == author
+        assert not any((
+            self.imc.added,
+            self.imc.changed,
+            self.imc.removed
+        ))
         for node in to_add:
-            self.assertEqual(newtip.get_node(node.path).content, node.content)
+            assert newtip.get_node(node.path).content == node.content
 
     def test_add_actually_adds_all_nodes_at_second_commit_too(self):
         self.imc.add(FileNode('foo/bar/image.png', content='\0'))
         self.imc.add(FileNode('foo/README.txt', content='readme!'))
         changeset = self.imc.commit(u'Initial', u'[e-mail]')
-        self.assertTrue(isinstance(changeset.get_node('foo'), DirNode))
-        self.assertTrue(isinstance(changeset.get_node('foo/bar'), DirNode))
-        self.assertEqual(changeset.get_node('foo/bar/image.png').content, '\0')
-        self.assertEqual(changeset.get_node('foo/README.txt').content, 'readme!')
+        assert isinstance(changeset.get_node('foo'), DirNode)
+        assert isinstance(changeset.get_node('foo/bar'), DirNode)
+        assert changeset.get_node('foo/bar/image.png').content == '\0'
+        assert changeset.get_node('foo/README.txt').content == 'readme!'
 
         # commit some more files again
         to_add = [
@@ -109,11 +115,11 b' class InMemoryChangesetTestMixin(object)'
         ]
         self.imc.add(*to_add)
         changeset = self.imc.commit(u'Another', u'[e-mail]')
-        self.assertEqual(changeset.get_node('foo/bar/foobaz/bar').content, 'foo')
-        self.assertEqual(changeset.get_node('foo/bar/another/bar').content, 'foo')
-        self.assertEqual(changeset.get_node('foo/baz.txt').content, 'foo')
-        self.assertEqual(changeset.get_node('foobar/foobaz/file').content, 'foo')
-        self.assertEqual(changeset.get_node('foobar/barbaz').content, 'foo')
+        changeset.get_node('foo/bar/foobaz/bar').content == 'foo'
+        changeset.get_node('foo/bar/another/bar').content == 'foo'
+        changeset.get_node('foo/baz.txt').content == 'foo'
+        changeset.get_node('foobar/foobaz/file').content == 'foo'
+        changeset.get_node('foobar/barbaz').content == 'foo'
 
     def test_add_non_ascii_files(self):
         rev_count = len(self.repo.revisions)
@@ -128,28 +134,32 b' class InMemoryChangesetTestMixin(object)'
         changeset = self.imc.commit(message=message, author=author)
 
         newtip = self.repo.get_changeset()
-        self.assertEqual(changeset, newtip)
-        self.assertEqual(rev_count + 1, len(self.repo.revisions))
-        self.assertEqual(newtip.message, message)
-        self.assertEqual(newtip.author, author)
-        self.assertTrue(not any((self.imc.added, self.imc.changed,
-            self.imc.removed)))
+        assert changeset == newtip
+        assert rev_count + 1 == len(self.repo.revisions)
+        assert newtip.message == message
+        assert newtip.author == author
+        assert not any((
+            self.imc.added,
+            self.imc.changed,
+            self.imc.removed
+        ))
         for node in to_add:
-            self.assertEqual(newtip.get_node(node.path).content, node.content)
+            assert newtip.get_node(node.path).content == node.content
 
     def test_add_raise_already_added(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
-        self.assertRaises(NodeAlreadyAddedError, self.imc.add, node)
+        with pytest.raises(NodeAlreadyAddedError):
+            self.imc.add(node)
 
     def test_check_integrity_raise_already_exist(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=unicode(self))
         self.imc.add(node)
-        self.assertRaises(NodeAlreadyExistsError, self.imc.commit,
-            message='new message',
-            author=str(self))
+        with pytest.raises(NodeAlreadyExistsError):
+            self.imc.commit(message='new message',
+                            author=str(self))
 
     def test_change(self):
         self.imc.add(FileNode('foo/bar/baz', content='foo'))
@@ -162,10 +172,9 b' class InMemoryChangesetTestMixin(object)'
         self.imc.commit(u'Changed %s' % node.path, u'[e-mail]')
 
         newtip = self.repo.get_changeset()
-        self.assertNotEqual(tip, newtip)
-        self.assertNotEqual(tip.id, newtip.id)
-        self.assertEqual(newtip.get_node('foo/bar/baz').content,
-                        'My **changed** content')
+        assert tip != newtip
+        assert tip.id != newtip.id
+        assert newtip.get_node('foo/bar/baz').content == 'My **changed** content'
 
     def test_change_non_ascii(self):
         to_add = [
@@ -189,17 +198,16 b' class InMemoryChangesetTestMixin(object)'
                         u'[e-mail]')
 
         newtip = self.repo.get_changeset()
-        self.assertNotEqual(tip, newtip)
-        self.assertNotEqual(tip.id, newtip.id)
+        assert tip != newtip
+        assert tip.id != newtip.id
 
-        self.assertEqual(newtip.get_node('żółwik/zwierzątko').content,
-                         'My **changed** content')
-        self.assertEqual(newtip.get_node('żółwik/zwierzątko_uni').content,
-                         'My **changed** content')
+        assert newtip.get_node('żółwik/zwierzątko').content == 'My **changed** content'
+        assert newtip.get_node('żółwik/zwierzątko_uni').content == 'My **changed** content'
 
     def test_change_raise_empty_repository(self):
         node = FileNode('foobar')
-        self.assertRaises(EmptyRepositoryError, self.imc.change, node)
+        with pytest.raises(EmptyRepositoryError):
+            self.imc.change(node)
 
     def test_check_integrity_change_raise_node_does_not_exist(self):
         node = FileNode('foobar', content='baz')
@@ -207,9 +215,8 b' class InMemoryChangesetTestMixin(object)'
         self.imc.commit(message=u'Added foobar', author=unicode(self))
         node = FileNode('not-foobar', content='')
         self.imc.change(node)
-        self.assertRaises(NodeDoesNotExistError, self.imc.commit,
-            message='Changed not existing node',
-            author=str(self))
+        with pytest.raises(NodeDoesNotExistError):
+            self.imc.commit(message='Changed not existing node', author=str(self))
 
     def test_change_raise_node_already_changed(self):
         node = FileNode('foobar', content='baz')
@@ -217,37 +224,42 b' class InMemoryChangesetTestMixin(object)'
         self.imc.commit(message=u'Added foobar', author=unicode(self))
         node = FileNode('foobar', content='more baz')
         self.imc.change(node)
-        self.assertRaises(NodeAlreadyChangedError, self.imc.change, node)
+        with pytest.raises(NodeAlreadyChangedError):
+            self.imc.change(node)
 
     def test_check_integrity_change_raise_node_not_changed(self):
         self.test_add()  # Performs first commit
 
         node = FileNode(self.nodes[0].path, content=self.nodes[0].content)
         self.imc.change(node)
-        self.assertRaises(NodeNotChangedError, self.imc.commit,
-            message=u'Trying to mark node as changed without touching it',
-            author=unicode(self))
+        with pytest.raises(NodeNotChangedError):
+            self.imc.commit(
+                message=u'Trying to mark node as changed without touching it',
+                author=unicode(self)
+            )
 
     def test_change_raise_node_already_removed(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=unicode(self))
         self.imc.remove(FileNode('foobar'))
-        self.assertRaises(NodeAlreadyRemovedError, self.imc.change, node)
+        with pytest.raises(NodeAlreadyRemovedError):
+            self.imc.change(node)
 
     def test_remove(self):
         self.test_add()  # Performs first commit
 
         tip = self.repo.get_changeset()
         node = self.nodes[0]
-        self.assertEqual(node.content, tip.get_node(node.path).content)
+        assert node.content == tip.get_node(node.path).content
         self.imc.remove(node)
         self.imc.commit(message=u'Removed %s' % node.path, author=unicode(self))
 
         newtip = self.repo.get_changeset()
-        self.assertNotEqual(tip, newtip)
-        self.assertNotEqual(tip.id, newtip.id)
-        self.assertRaises(NodeDoesNotExistError, newtip.get_node, node.path)
+        assert tip != newtip
+        assert tip.id != newtip.id
+        with pytest.raises(NodeDoesNotExistError):
+            newtip.get_node(node.path)
 
     def test_remove_last_file_from_directory(self):
         node = FileNode('omg/qwe/foo/bar', content='foobar')
@@ -256,44 +268,54 b' class InMemoryChangesetTestMixin(object)'
 
         self.imc.remove(node)
         tip = self.imc.commit(u'removed', u'joe doe')
-        self.assertRaises(NodeDoesNotExistError, tip.get_node, 'omg/qwe/foo/bar')
+        with pytest.raises(NodeDoesNotExistError):
+            tip.get_node('omg/qwe/foo/bar')
 
     def test_remove_raise_node_does_not_exist(self):
         self.imc.remove(self.nodes[0])
-        self.assertRaises(NodeDoesNotExistError, self.imc.commit,
-            message='Trying to remove node at empty repository',
-            author=str(self))
+        with pytest.raises(NodeDoesNotExistError):
+            self.imc.commit(
+                message='Trying to remove node at empty repository',
+                author=str(self)
+            )
 
     def test_check_integrity_remove_raise_node_does_not_exist(self):
         self.test_add()  # Performs first commit
 
         node = FileNode('no-such-file')
         self.imc.remove(node)
-        self.assertRaises(NodeDoesNotExistError, self.imc.commit,
-            message=u'Trying to remove not existing node',
-            author=unicode(self))
+        with pytest.raises(NodeDoesNotExistError):
+            self.imc.commit(
+                message=u'Trying to remove not existing node',
+                author=unicode(self)
+            )
 
     def test_remove_raise_node_already_removed(self):
         self.test_add() # Performs first commit
 
         node = FileNode(self.nodes[0].path)
         self.imc.remove(node)
-        self.assertRaises(NodeAlreadyRemovedError, self.imc.remove, node)
+        with pytest.raises(NodeAlreadyRemovedError):
+            self.imc.remove(node)
 
     def test_remove_raise_node_already_changed(self):
         self.test_add()  # Performs first commit
 
         node = FileNode(self.nodes[0].path, content='Bending time')
         self.imc.change(node)
-        self.assertRaises(NodeAlreadyChangedError, self.imc.remove, node)
+        with pytest.raises(NodeAlreadyChangedError):
+            self.imc.remove(node)
 
     def test_reset(self):
         self.imc.add(FileNode('foo', content='bar'))
         #self.imc.change(FileNode('baz', content='new'))
         #self.imc.remove(FileNode('qwe'))
         self.imc.reset()
-        self.assertTrue(not any((self.imc.added, self.imc.changed,
-            self.imc.removed)))
+        assert not any((
+            self.imc.added,
+            self.imc.changed,
+            self.imc.removed
+        ))
 
     def test_multiple_commits(self):
         N = 3  # number of commits to perform
@@ -304,16 +326,16 b' class InMemoryChangesetTestMixin(object)'
             node = FileNode(fname, content=content)
             self.imc.add(node)
             commit = self.imc.commit(u"Commit no. %s" % (x + 1), author=u'vcs')
-            self.assertTrue(last != commit)
+            assert last != commit
             last = commit
 
         # Check commit number for same repo
-        self.assertEqual(len(self.repo.revisions), N)
+        assert len(self.repo.revisions) == N
 
         # Check commit number for recreated repo
         backend = self.get_backend()
         repo = backend(self.repo_path)
-        self.assertEqual(len(repo.revisions), N)
+        assert len(repo.revisions) == N
 
     def test_date_attr(self):
         node = FileNode('foobar.txt', content='Foobared!')
@@ -322,10 +344,10 b' class InMemoryChangesetTestMixin(object)'
         commit = self.imc.commit(u"Committed at time when I was born ;-)",
             author=u'lb <[e-mail]>', date=date)
 
-        self.assertEqual(commit.date, date)
+        assert commit.date == date
 
 
-class BackendBaseTestCase(unittest.TestCase):
+class BackendBaseTestCase(object):
     """
     Base test class for tests which requires repository.
     """
@@ -361,7 +383,7 b' class BackendBaseTestCase(unittest.TestC'
         repo_path = get_new_dir(key)
         return repo_path
 
-    def setUp(self):
+    def setup_method(self):
         Backend = self.get_backend()
         self.backend_class = Backend
         self.repo_path = self.get_new_repo_path()
@@ -387,6 +409,5 b' for alias in SCM_TESTS:'
     attrs = {
         'backend_alias': alias,
     }
-    cls_name = ''.join(('%s in memory changeset test' % alias).title().split())
-    bases = (InMemoryChangesetTestMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = ''.join(('test %s in memory changeset' % alias).title().split())
+    globals()[cls_name] = type(cls_name, (InMemoryChangesetTestMixin,), attrs)

kallithea/tests/vcs/test_nodes.py

@@ -1,7 +1,7 b''
 import stat
 import mimetypes
 
-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 
 from kallithea.lib.vcs.nodes import DirNode
 from kallithea.lib.vcs.nodes import FileNode
@@ -10,7 +10,7 b' from kallithea.lib.vcs.nodes import Node'
 from kallithea.lib.vcs.nodes import NodeKind
 
 
-class NodeBasicTest(unittest.TestCase):
+class TestNodeBasic(object):
 
     def test_init(self):
         """
@@ -21,37 +21,41 b' class NodeBasicTest(unittest.TestCase):'
             '/foo/bar'
         )
         for path in wrong_paths:
-            self.assertRaises(NodeError, Node, path, NodeKind.FILE)
+            with pytest.raises(NodeError):
+                Node(path, NodeKind.FILE)
 
         wrong_paths = (
             '/foo/',
             '/foo/bar/'
         )
         for path in wrong_paths:
-            self.assertRaises(NodeError, Node, path, NodeKind.DIR)
+            with pytest.raises(NodeError):
+                Node(path, NodeKind.DIR)
 
     def test_name(self):
         node = Node('', NodeKind.DIR)
-        self.assertEqual(node.name, '')
+        assert node.name == ''
 
         node = Node('path', NodeKind.FILE)
-        self.assertEqual(node.name, 'path')
+        assert node.name == 'path'
 
         node = Node('path/', NodeKind.DIR)
-        self.assertEqual(node.name, 'path')
+        assert node.name == 'path'
 
         node = Node('some/path', NodeKind.FILE)
-        self.assertEqual(node.name, 'path')
+        assert node.name == 'path'
 
         node = Node('some/path/', NodeKind.DIR)
-        self.assertEqual(node.name, 'path')
+        assert node.name == 'path'
 
     def test_root_node(self):
-        self.assertRaises(NodeError, Node, '', NodeKind.FILE)
+        with pytest.raises(NodeError):
+            Node('', NodeKind.FILE)
 
     def test_kind_setter(self):
         node = Node('', NodeKind.DIR)
-        self.assertRaises(NodeError, setattr, node, 'kind', NodeKind.FILE)
+        with pytest.raises(NodeError):
+            setattr(node, 'kind', NodeKind.FILE)
 
     def _test_parent_path(self, node_path, expected_parent_path):
         """
@@ -59,11 +63,10 b' class NodeBasicTest(unittest.TestCase):'
         """
         node = Node(node_path, NodeKind.DIR)
         parent_path = node.get_parent_path()
-        self.assertTrue(parent_path.endswith('/') or \
-            node.is_root() and parent_path == '')
-        self.assertEqual(parent_path, expected_parent_path,
-            "Node's path is %r and parent path is %r but should be %r"
-            % (node.path, parent_path, expected_parent_path))
+        assert parent_path.endswith('/') or node.is_root() and parent_path == ''
+        assert parent_path == expected_parent_path, \
+            "Node's path is %r and parent path is %r but should be %r" \
+            % (node.path, parent_path, expected_parent_path)
 
     def test_parent_path(self):
         test_paths = (
@@ -80,7 +83,8 b' class NodeBasicTest(unittest.TestCase):'
         if not path.endswith('/'):
             pytest.fail("Trailing slash tests needs paths to end with slash")
         for kind in NodeKind.FILE, NodeKind.DIR:
-            self.assertRaises(NodeError, Node, path=path, kind=kind)
+            with pytest.raises(NodeError):
+                Node(path=path, kind=kind)
 
     def test_trailing_slash(self):
         for path in ('/', 'foo/', 'foo/bar/', 'foo/bar/biz/'):
@@ -89,20 +93,22 b' class NodeBasicTest(unittest.TestCase):'
 
     def test_is_file(self):
         node = Node('any', NodeKind.FILE)
-        self.assertTrue(node.is_file())
+        assert node.is_file()
 
         node = FileNode('any')
-        self.assertTrue(node.is_file())
-        self.assertRaises(AttributeError, getattr, node, 'nodes')
+        assert node.is_file()
+        with pytest.raises(AttributeError):
+            getattr(node, 'nodes')
 
     def test_is_dir(self):
         node = Node('any_dir', NodeKind.DIR)
-        self.assertTrue(node.is_dir())
+        assert node.is_dir()
 
         node = DirNode('any_dir')
 
-        self.assertTrue(node.is_dir())
-        self.assertRaises(NodeError, getattr, node, 'content')
+        assert node.is_dir()
+        with pytest.raises(NodeError):
+            getattr(node, 'content')
 
     def test_dir_node_iter(self):
         nodes = [
@@ -122,32 +128,34 b' class NodeBasicTest(unittest.TestCase):'
         Without link to changeset nodes should raise NodeError.
         """
         node = FileNode('anything')
-        self.assertRaises(NodeError, getattr, node, 'state')
+        with pytest.raises(NodeError):
+            getattr(node, 'state')
         node = DirNode('anything')
-        self.assertRaises(NodeError, getattr, node, 'state')
+        with pytest.raises(NodeError):
+            getattr(node, 'state')
 
     def test_file_node_stat(self):
         node = FileNode('foobar', 'empty... almost')
         mode = node.mode  # default should be 0100644
-        self.assertTrue(mode & stat.S_IRUSR)
-        self.assertTrue(mode & stat.S_IWUSR)
-        self.assertTrue(mode & stat.S_IRGRP)
-        self.assertTrue(mode & stat.S_IROTH)
-        self.assertFalse(mode & stat.S_IWGRP)
-        self.assertFalse(mode & stat.S_IWOTH)
-        self.assertFalse(mode & stat.S_IXUSR)
-        self.assertFalse(mode & stat.S_IXGRP)
-        self.assertFalse(mode & stat.S_IXOTH)
+        assert mode & stat.S_IRUSR
+        assert mode & stat.S_IWUSR
+        assert mode & stat.S_IRGRP
+        assert mode & stat.S_IROTH
+        assert not mode & stat.S_IWGRP
+        assert not mode & stat.S_IWOTH
+        assert not mode & stat.S_IXUSR
+        assert not mode & stat.S_IXGRP
+        assert not mode & stat.S_IXOTH
 
     def test_file_node_is_executable(self):
         node = FileNode('foobar', 'empty... almost', mode=0100755)
-        self.assertTrue(node.is_executable)
+        assert node.is_executable
 
         node = FileNode('foobar', 'empty... almost', mode=0100500)
-        self.assertTrue(node.is_executable)
+        assert node.is_executable
 
         node = FileNode('foobar', 'empty... almost', mode=0100644)
-        self.assertFalse(node.is_executable)
+        assert not node.is_executable
 
     def test_mimetype(self):
         py_node = FileNode('test.py')
@@ -159,22 +167,22 b' class NodeBasicTest(unittest.TestCase):'
         my_node3 = FileNode('myfile3')
         my_node3._content = '\0foobar'
 
-        self.assertEqual(py_node.mimetype, mimetypes.guess_type(py_node.name)[0])
-        self.assertEqual(py_node.get_mimetype(), mimetypes.guess_type(py_node.name))
+        assert py_node.mimetype == mimetypes.guess_type(py_node.name)[0]
+        assert py_node.get_mimetype() == mimetypes.guess_type(py_node.name)
 
-        self.assertEqual(tar_node.mimetype, mimetypes.guess_type(tar_node.name)[0])
-        self.assertEqual(tar_node.get_mimetype(), mimetypes.guess_type(tar_node.name))
+        assert tar_node.mimetype == mimetypes.guess_type(tar_node.name)[0]
+        assert tar_node.get_mimetype() == mimetypes.guess_type(tar_node.name)
 
-        self.assertEqual(my_node2.mimetype, 'text/plain')
-        self.assertEqual(my_node2.get_mimetype(), ('text/plain', None))
+        assert my_node2.mimetype == 'text/plain'
+        assert my_node2.get_mimetype() == ('text/plain', None)
 
-        self.assertEqual(my_node3.mimetype, 'application/octet-stream')
-        self.assertEqual(my_node3.get_mimetype(), ('application/octet-stream', None))
+        assert my_node3.mimetype == 'application/octet-stream'
+        assert my_node3.get_mimetype() == ('application/octet-stream', None)
 
 
-class NodeContentTest(unittest.TestCase):
+class TestNodeContent(object):
 
     def test_if_binary(self):
         data = """\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f??a\x00\x00\x00\x04gAMA\x00\x00\xaf?7\x05\x8a?\x00\x00\x00\x19tEXtSoftware\x00Adobe ImageReadyq?e<\x00\x00\x025IDAT8?\xa5\x93?K\x94Q\x14\x87\x9f\xf7?Q\x1bs4?\x03\x9a\xa8?B\x02\x8b$\x10[U;i\x13?6h?&h[?"\x14j?\xa2M\x7fB\x14F\x9aQ?&\x842?\x0b\x89"\x82??!?\x9c!\x9c2l??{N\x8bW\x9dY\xb4\t/\x1c?=\x9b?}????\xa9*;9!?\x83\x91?[?\\v*?D\x04\'`EpNp\xa2X\'U?pVq"Sw.\x1e?\x08\x01D?jw????\xbc??7{|\x9b?\x89$\x01??W@\x15\x9c\x05q`Lt/\x97?\x94\xa1d?\x18~?\x18?\x18W[%\xb0?\x83??\x14\x88\x8dB?\xa6H\tL\tl\x19>/\x01`\xac\xabx?\x9cl\nx\xb0\x98\x07\x95\x88D$"q[\x19?d\x00(o\n\xa0??\x7f\xb9\xa4?\x1bF\x1f\x8e\xac\xa8?j??eUU}?.?\x9f\x8cE??x\x94??\r\xbdtoJU5"0N\x10U?\x00??V\t\x02\x9f\x81?U?\x00\x9eM\xae2?r\x9b7\x83\x82\x8aP3????.?&"?\xb7ZP \x0c<?O\xa5\t}\xb8?\x99\xa6?\x87?\x1di|/\xa0??0\xbe\x1fp?d&\x1a\xad\x95\x8a\x07?\t*\x10??b:?d?.\x13C\x8a?\x12\xbe\xbf\x8e?{???\x08?\x80\xa7\x13+d\x13>J?\x80\x15T\x95\x9a\x00??S\x8c\r?\xa1\x03\x07?\x96\x9b\xa7\xab=E??\xa4\xb3?\x19q??B\x91=\x8d??k?J\x0bV"??\xf7x?\xa1\x00?\\.\x87\x87???\x02F@D\x99],??\x10#?X\xb7=\xb9\x10?Z\x1by???cI??\x1ag?\x92\xbc?T?t[\x92\x81?<_\x17~\x92\x88?H%?\x10Q\x02\x9f\n\x81qQ\x0bm?\x1bX?\xb1AK\xa6\x9e\xb9?u\xb2?1\xbe|/\x92M@\xa2!F?\xa9>"\r<DT?>\x92\x8e?>\x9a9Qv\x127?a\xac?Y?8?:??]X???9\x80\xb7?u?\x0b#BZ\x8d=\x1d?p\x00\x00\x00\x00IEND\xaeB`\x82"""
         filenode = FileNode('calendar.png', content=data)
-        self.assertTrue(filenode.is_binary)
+        assert filenode.is_binary

kallithea/tests/vcs/test_repository.py

@@ -1,6 +1,6 b''
 import datetime
 
-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 
 from kallithea.lib.vcs.nodes import FileNode
 from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError
@@ -18,34 +18,30 b' class RepositoryBaseTest(_BackendTestMix'
         return super(RepositoryBaseTest, cls)._get_commits()[:1]
 
     def test_get_config_value(self):
-        self.assertEqual(self.repo.get_config_value('universal', 'foo',
-            TEST_USER_CONFIG_FILE), 'bar')
+        assert self.repo.get_config_value('universal', 'foo', TEST_USER_CONFIG_FILE) == 'bar'
 
     def test_get_config_value_defaults_to_None(self):
-        self.assertEqual(self.repo.get_config_value('universal', 'nonexist',
-            TEST_USER_CONFIG_FILE), None)
+        assert self.repo.get_config_value('universal', 'nonexist', TEST_USER_CONFIG_FILE) == None
 
     def test_get_user_name(self):
-        self.assertEqual(self.repo.get_user_name(TEST_USER_CONFIG_FILE),
-            'Foo Bar')
+        assert self.repo.get_user_name(TEST_USER_CONFIG_FILE) == 'Foo Bar'
 
     def test_get_user_email(self):
-        self.assertEqual(self.repo.get_user_email(TEST_USER_CONFIG_FILE),
-            '[e-mail]')
+        assert self.repo.get_user_email(TEST_USER_CONFIG_FILE) == '[e-mail]'
 
     def test_repo_equality(self):
-        self.assertTrue(self.repo == self.repo)
+        assert self.repo == self.repo
 
     def test_repo_equality_broken_object(self):
         import copy
         _repo = copy.copy(self.repo)
         delattr(_repo, 'path')
-        self.assertTrue(self.repo != _repo)
+        assert self.repo != _repo
 
     def test_repo_equality_other_object(self):
         class dummy(object):
             path = self.repo.path
-        self.assertTrue(self.repo != dummy())
+        assert self.repo != dummy()
 
 
 class RepositoryGetDiffTest(_BackendTestMixin):
@@ -86,16 +82,16 b' class RepositoryGetDiffTest(_BackendTest'
         return commits
 
     def test_raise_for_wrong(self):
-        with self.assertRaises(ChangesetDoesNotExistError):
+        with pytest.raises(ChangesetDoesNotExistError):
             self.repo.get_diff('a' * 40, 'b' * 40)
 
 
-class GitRepositoryGetDiffTest(RepositoryGetDiffTest, unittest.TestCase):
+class TestGitRepositoryGetDiff(RepositoryGetDiffTest):
     backend_alias = 'git'
 
     def test_initial_commit_diff(self):
         initial_rev = self.repo.revisions[0]
-        self.assertEqual(self.repo.get_diff(self.repo.EMPTY_CHANGESET, initial_rev), '''diff --git a/foobar b/foobar
+        assert self.repo.get_diff(self.repo.EMPTY_CHANGESET, initial_rev) == '''diff --git a/foobar b/foobar
 new file mode 100644
 index 0000000000000000000000000000000000000000..f6ea0495187600e7b2288c8ac19c5886383a4632
 --- /dev/null
@@ -111,11 +107,11 b' index 0000000000000000000000000000000000'
 @@ -0,0 +1 @@
 +foobar2
 \ No newline at end of file
-''')
+'''
 
     def test_second_changeset_diff(self):
         revs = self.repo.revisions
-        self.assertEqual(self.repo.get_diff(revs[0], revs[1]), '''diff --git a/foobar b/foobar
+        assert self.repo.get_diff(revs[0], revs[1]) == '''diff --git a/foobar b/foobar
 index f6ea0495187600e7b2288c8ac19c5886383a4632..389865bb681b358c9b102d79abd8d5f941e96551 100644
 --- a/foobar
 +++ b/foobar
@@ -132,11 +128,11 b' index 0000000000000000000000000000000000'
 @@ -0,0 +1 @@
 +foobar3
 \ No newline at end of file
-''')
+'''
 
     def test_third_changeset_diff(self):
         revs = self.repo.revisions
-        self.assertEqual(self.repo.get_diff(revs[1], revs[2]), '''diff --git a/foobar b/foobar
+        assert self.repo.get_diff(revs[1], revs[2]) == '''diff --git a/foobar b/foobar
 deleted file mode 100644
 index 389865bb681b358c9b102d79abd8d5f941e96551..0000000000000000000000000000000000000000
 --- a/foobar
@@ -154,15 +150,15 b' index c11c37d41d33fb47741cff93fa5f9d798c'
 +FOOBAR
 +FOOBAR
 +FOOBAR
-''')
+'''
 
 
-class HgRepositoryGetDiffTest(RepositoryGetDiffTest, unittest.TestCase):
+class TestHgRepositoryGetDiff(RepositoryGetDiffTest):
     backend_alias = 'hg'
 
     def test_initial_commit_diff(self):
         initial_rev = self.repo.revisions[0]
-        self.assertEqual(self.repo.get_diff(self.repo.EMPTY_CHANGESET, initial_rev), '''diff --git a/foobar b/foobar
+        assert self.repo.get_diff(self.repo.EMPTY_CHANGESET, initial_rev) == '''diff --git a/foobar b/foobar
 new file mode 100644
 --- /dev/null
 +++ b/foobar
@@ -176,11 +172,11 b' new file mode 100644'
 @@ -0,0 +1,1 @@
 +foobar2
 \ No newline at end of file
-''')
+'''
 
     def test_second_changeset_diff(self):
         revs = self.repo.revisions
-        self.assertEqual(self.repo.get_diff(revs[0], revs[1]), '''diff --git a/foobar b/foobar
+        assert self.repo.get_diff(revs[0], revs[1]) == '''diff --git a/foobar b/foobar
 --- a/foobar
 +++ b/foobar
 @@ -1,1 +1,1 @@
@@ -195,11 +191,11 b' new file mode 100644'
 @@ -0,0 +1,1 @@
 +foobar3
 \ No newline at end of file
-''')
+'''
 
     def test_third_changeset_diff(self):
         revs = self.repo.revisions
-        self.assertEqual(self.repo.get_diff(revs[1], revs[2]), '''diff --git a/foobar b/foobar
+        assert self.repo.get_diff(revs[1], revs[2]) == '''diff --git a/foobar b/foobar
 deleted file mode 100644
 --- a/foobar
 +++ /dev/null
@@ -215,7 +211,7 b' diff --git a/foobar3 b/foobar3'
 +FOOBAR
 +FOOBAR
 +FOOBAR
-''')
+'''
 
 
 # For each backend create test case class
@@ -223,6 +219,5 b' for alias in SCM_TESTS:'
     attrs = {
         'backend_alias': alias,
     }
-    cls_name = alias.capitalize() + RepositoryBaseTest.__name__
-    bases = (RepositoryBaseTest, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = 'Test' + alias.capitalize() + RepositoryBaseTest.__name__
+    globals()[cls_name] = type(cls_name, (RepositoryBaseTest,), attrs)

kallithea/tests/vcs/test_tags.py

@@ -1,4 +1,4 b''
-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 
 from kallithea.lib.vcs.exceptions import TagAlreadyExistError
 from kallithea.lib.vcs.exceptions import TagDoesNotExistError
@@ -14,20 +14,20 b' class TagsTestCaseMixin(_BackendTestMixi'
         tagsize = len(self.repo.tags)
         tag = self.repo.tag('last-commit', 'joe', tip.raw_id)
 
-        self.assertEqual(len(self.repo.tags), tagsize + 1)
+        assert len(self.repo.tags) == tagsize + 1
         for top, dirs, files in tip.walk():
-            self.assertEqual(top, tag.get_node(top.path))
+            assert top == tag.get_node(top.path)
 
     def test_tag_already_exist(self):
         tip = self.repo.get_changeset()
         self.repo.tag('last-commit', 'joe', tip.raw_id)
 
-        self.assertRaises(TagAlreadyExistError,
-            self.repo.tag, 'last-commit', 'joe', tip.raw_id)
+        with pytest.raises(TagAlreadyExistError):
+            self.repo.tag('last-commit', 'joe', tip.raw_id)
 
         chset = self.repo.get_changeset(0)
-        self.assertRaises(TagAlreadyExistError,
-            self.repo.tag, 'last-commit', 'jane', chset.raw_id)
+        with pytest.raises(TagAlreadyExistError):
+            self.repo.tag('last-commit', 'jane', chset.raw_id)
 
     def test_remove_tag(self):
         tip = self.repo.get_changeset()
@@ -35,15 +35,15 b' class TagsTestCaseMixin(_BackendTestMixi'
         tagsize = len(self.repo.tags)
 
         self.repo.remove_tag('last-commit', user='evil joe')
-        self.assertEqual(len(self.repo.tags), tagsize - 1)
+        assert len(self.repo.tags) == tagsize - 1
 
     def test_remove_tag_which_does_not_exist(self):
-        self.assertRaises(TagDoesNotExistError,
-            self.repo.remove_tag, 'last-commit', user='evil joe')
+        with pytest.raises(TagDoesNotExistError):
+            self.repo.remove_tag('last-commit', user='evil joe')
 
     def test_name_with_slash(self):
         self.repo.tag('19/10/11', 'joe')
-        self.assertTrue('19/10/11' in self.repo.tags)
+        assert '19/10/11' in self.repo.tags
 
 
 # For each backend create test case class
@@ -51,6 +51,5 b' for alias in SCM_TESTS:'
     attrs = {
         'backend_alias': alias,
     }
-    cls_name = ''.join(('%s tags test' % alias).title().split())
-    bases = (TagsTestCaseMixin, unittest.TestCase)
-    globals()[cls_name] = type(cls_name, bases, attrs)
+    cls_name = ''.join(('test %s tags' % alias).title().split())
+    globals()[cls_name] = type(cls_name, (TagsTestCaseMixin,), attrs)

kallithea/tests/vcs/test_utils.py

@@ -6,7 +6,7 b' import time'
 import shutil
 import datetime
 
-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 
 from kallithea.lib.vcs.utils.paths import get_dirs_for_path
 from kallithea.lib.vcs.utils.helpers import get_dict_for_attrs
@@ -22,7 +22,7 b' from kallithea.lib.vcs.exceptions import'
 from kallithea.tests.vcs.conf import TEST_HG_REPO, TEST_GIT_REPO, TESTS_TMP_PATH
 
 
-class PathsTest(unittest.TestCase):
+class TestPaths(object):
 
     def _test_get_dirs_for_path(self, path, expected):
         """
@@ -30,9 +30,8 b' class PathsTest(unittest.TestCase):'
         """
         expected = sorted(expected)
         result = sorted(get_dirs_for_path(path))
-        self.assertEqual(result, expected,
-            msg="%s != %s which was expected result for path %s"
-            % (result, expected, path))
+        assert result == expected, \
+            "%s != %s which was expected result for path %s" % (result, expected, path)
 
     def test_get_dirs_for_path(self):
         path = 'foo/bar/baz/file'
@@ -45,8 +44,8 b' class PathsTest(unittest.TestCase):'
             self._test_get_dirs_for_path(path, expected)
 
     def test_get_scm(self):
-        self.assertEqual(('hg', TEST_HG_REPO), get_scm(TEST_HG_REPO))
-        self.assertEqual(('git', TEST_GIT_REPO), get_scm(TEST_GIT_REPO))
+        assert ('hg', TEST_HG_REPO) == get_scm(TEST_HG_REPO)
+        assert ('git', TEST_GIT_REPO) == get_scm(TEST_GIT_REPO)
 
     def test_get_two_scms_for_path(self):
         multialias_repo_path = os.path.join(TESTS_TMP_PATH, 'hg-git-repo-2')
@@ -55,135 +54,130 b' class PathsTest(unittest.TestCase):'
 
         os.mkdir(multialias_repo_path)
 
-        self.assertRaises(VCSError, get_scm, multialias_repo_path)
+        with pytest.raises(VCSError):
+            get_scm(multialias_repo_path)
 
     def test_get_scm_error_path(self):
-        self.assertRaises(VCSError, get_scm, 'err')
+        with pytest.raises(VCSError):
+            get_scm('err')
 
     def test_get_scms_for_path(self):
         new = os.path.join(TESTS_TMP_PATH, 'vcs-scms-for-path-%s' % time.time())
         os.mkdir(new)
-        self.assertEqual(get_scms_for_path(new), [])
+        assert get_scms_for_path(new) == []
 
         os.mkdir(os.path.join(new, '.tux'))
-        self.assertEqual(get_scms_for_path(new), [])
+        assert get_scms_for_path(new) == []
 
         os.mkdir(os.path.join(new, '.git'))
-        self.assertEqual(set(get_scms_for_path(new)), set(['git']))
+        assert set(get_scms_for_path(new)) == set(['git'])
 
         os.mkdir(os.path.join(new, '.hg'))
-        self.assertEqual(set(get_scms_for_path(new)), set(['git', 'hg']))
+        assert set(get_scms_for_path(new)) == set(['git', 'hg'])
 
 
-class TestParseChangesets(unittest.TestCase):
+class TestParseChangesets(object):
 
     def test_main_is_returned_correctly(self):
-        self.assertEqual(parse_changesets('123456'), {
+        assert parse_changesets('123456') == {
             'start': None,
             'main': '123456',
             'end': None,
-        })
+        }
 
     def test_start_is_returned_correctly(self):
-        self.assertEqual(parse_changesets('aaabbb..'), {
+        assert parse_changesets('aaabbb..') == {
             'start': 'aaabbb',
             'main': None,
             'end': None,
-        })
+        }
 
     def test_end_is_returned_correctly(self):
-        self.assertEqual(parse_changesets('..cccddd'), {
+        assert parse_changesets('..cccddd') == {
             'start': None,
             'main': None,
             'end': 'cccddd',
-        })
+        }
 
     def test_that_two_or_three_dots_are_allowed(self):
         text1 = 'a..b'
         text2 = 'a...b'
-        self.assertEqual(parse_changesets(text1), parse_changesets(text2))
+        assert parse_changesets(text1) == parse_changesets(text2)
 
     def test_that_input_is_stripped_first(self):
         text1 = 'a..bb'
         text2 = '  a..bb\t\n\t '
-        self.assertEqual(parse_changesets(text1), parse_changesets(text2))
+        assert parse_changesets(text1) == parse_changesets(text2)
 
     def test_that_exception_is_raised(self):
         text = '123456.789012' # single dot is not recognized
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             parse_changesets(text)
 
     def test_non_alphanumeric_raises_exception(self):
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             parse_changesets('aaa@bbb')
 
 
-class TestParseDatetime(unittest.TestCase):
+class TestParseDatetime(object):
 
     def test_datetime_text(self):
-        self.assertEqual(parse_datetime('2010-04-07 21:29:41'),
-            datetime.datetime(2010, 4, 7, 21, 29, 41))
+        assert parse_datetime('2010-04-07 21:29:41') == datetime.datetime(2010, 4, 7, 21, 29, 41)
 
     def test_no_seconds(self):
-        self.assertEqual(parse_datetime('2010-04-07 21:29'),
-            datetime.datetime(2010, 4, 7, 21, 29))
+        assert parse_datetime('2010-04-07 21:29') == datetime.datetime(2010, 4, 7, 21, 29)
 
     def test_date_only(self):
-        self.assertEqual(parse_datetime('2010-04-07'),
-            datetime.datetime(2010, 4, 7))
+        assert parse_datetime('2010-04-07') == datetime.datetime(2010, 4, 7)
 
     def test_another_format(self):
-        self.assertEqual(parse_datetime('04/07/10 21:29:41'),
-            datetime.datetime(2010, 4, 7, 21, 29, 41))
+        assert parse_datetime('04/07/10 21:29:41') == datetime.datetime(2010, 4, 7, 21, 29, 41)
 
     def test_now(self):
-        self.assertTrue(parse_datetime('now') - datetime.datetime.now() <
-            datetime.timedelta(seconds=1))
+        assert parse_datetime('now') - datetime.datetime.now() < datetime.timedelta(seconds=1)
 
     def test_today(self):
         today = datetime.date.today()
-        self.assertEqual(parse_datetime('today'),
-            datetime.datetime(*today.timetuple()[:3]))
+        assert parse_datetime('today') == datetime.datetime(*today.timetuple()[:3])
 
     def test_yesterday(self):
         yesterday = datetime.date.today() - datetime.timedelta(days=1)
-        self.assertEqual(parse_datetime('yesterday'),
-            datetime.datetime(*yesterday.timetuple()[:3]))
+        assert parse_datetime('yesterday') == datetime.datetime(*yesterday.timetuple()[:3])
 
     def test_tomorrow(self):
         tomorrow = datetime.date.today() + datetime.timedelta(days=1)
         args = tomorrow.timetuple()[:3] + (23, 59, 59)
-        self.assertEqual(parse_datetime('tomorrow'), datetime.datetime(*args))
+        assert parse_datetime('tomorrow') == datetime.datetime(*args)
 
     def test_days(self):
         timestamp = datetime.datetime.today() - datetime.timedelta(days=3)
         args = timestamp.timetuple()[:3] + (0, 0, 0, 0)
         expected = datetime.datetime(*args)
-        self.assertEqual(parse_datetime('3d'), expected)
-        self.assertEqual(parse_datetime('3 d'), expected)
-        self.assertEqual(parse_datetime('3 day'), expected)
-        self.assertEqual(parse_datetime('3 days'), expected)
+        assert parse_datetime('3d') == expected
+        assert parse_datetime('3 d') == expected
+        assert parse_datetime('3 day') == expected
+        assert parse_datetime('3 days') == expected
 
     def test_weeks(self):
         timestamp = datetime.datetime.today() - datetime.timedelta(days=3 * 7)
         args = timestamp.timetuple()[:3] + (0, 0, 0, 0)
         expected = datetime.datetime(*args)
-        self.assertEqual(parse_datetime('3w'), expected)
-        self.assertEqual(parse_datetime('3 w'), expected)
-        self.assertEqual(parse_datetime('3 week'), expected)
-        self.assertEqual(parse_datetime('3 weeks'), expected)
+        assert parse_datetime('3w') == expected
+        assert parse_datetime('3 w') == expected
+        assert parse_datetime('3 week') == expected
+        assert parse_datetime('3 weeks') == expected
 
     def test_mixed(self):
         timestamp = datetime.datetime.today() - datetime.timedelta(days=2 * 7 + 3)
         args = timestamp.timetuple()[:3] + (0, 0, 0, 0)
         expected = datetime.datetime(*args)
-        self.assertEqual(parse_datetime('2w3d'), expected)
-        self.assertEqual(parse_datetime('2w 3d'), expected)
-        self.assertEqual(parse_datetime('2w 3 days'), expected)
-        self.assertEqual(parse_datetime('2 weeks 3 days'), expected)
+        assert parse_datetime('2w3d') == expected
+        assert parse_datetime('2w 3d') == expected
+        assert parse_datetime('2w 3 days') == expected
+        assert parse_datetime('2 weeks 3 days') == expected
 
 
-class TestAuthorExtractors(unittest.TestCase):
+class TestAuthorExtractors(object):
     TEST_AUTHORS = [("Username Last'o'Name <[e-mail]>",
                     ("Username Last'o'Name", "[e-mail]")),
                   ("Username Last'o'Name Spaces < [e-mail] >",
@@ -210,14 +204,14 b' class TestAuthorExtractors(unittest.Test'
 
     def test_author_email(self):
         for test_str, result in self.TEST_AUTHORS:
-            self.assertEqual(result[1], author_email(test_str))
+            assert result[1] == author_email(test_str)
 
     def test_author_name(self):
         for test_str, result in self.TEST_AUTHORS:
-            self.assertEqual(result[0], author_name(test_str))
+            assert result[0] == author_name(test_str)
 
 
-class TestGetDictForAttrs(unittest.TestCase):
+class TestGetDictForAttrs(object):
 
     def test_returned_dict_has_expected_attrs(self):
         obj = mock.Mock()
@@ -228,23 +222,22 b' class TestGetDictForAttrs(unittest.TestC'
         obj.date = datetime.datetime(2010, 12, 31)
         obj.count = 1001
 
-        self.assertEqual(get_dict_for_attrs(obj, ['CONST', 'foo', 'attrs',
-            'date', 'count']), {
+        assert get_dict_for_attrs(obj, ['CONST', 'foo', 'attrs', 'date', 'count']) ==  {
             'CONST': True,
             'foo': 'aaa',
             'attrs': {'foo': 'bar'},
             'date': datetime.datetime(2010, 12, 31),
             'count': 1001,
-        })
+        }
 
 
-class TestGetTotalSeconds(unittest.TestCase):
+class TestGetTotalSeconds(object):
 
     def assertTotalSecondsEqual(self, timedelta, expected_seconds):
         result = get_total_seconds(timedelta)
-        self.assertEqual(result, expected_seconds,
-            "We computed %s seconds for %s but expected %s"
-            % (result, timedelta, expected_seconds))
+        assert result == expected_seconds, \
+            "We computed %s seconds for %s but expected %s" \
+            % (result, timedelta, expected_seconds)
 
     def test_get_total_seconds_returns_proper_value(self):
         self.assertTotalSecondsEqual(datetime.timedelta(seconds=1001), 1001)
@@ -253,21 +246,21 b' class TestGetTotalSeconds(unittest.TestC'
         self.assertTotalSecondsEqual(datetime.timedelta(seconds=50.65), 50.65)
 
 
-class TestGetUserHome(unittest.TestCase):
+class TestGetUserHome(object):
 
     @mock.patch.object(os, 'environ', {})
     def test_defaults_to_none(self):
-        self.assertEqual(get_user_home(), '')
+        assert get_user_home() == ''
 
     @mock.patch.object(os, 'environ', {'HOME': '/home/foobar'})
     def test_unix_like(self):
-        self.assertEqual(get_user_home(), '/home/foobar')
+        assert get_user_home() == '/home/foobar'
 
     @mock.patch.object(os, 'environ', {'USERPROFILE': '/Users/foobar'})
     def test_windows_like(self):
-        self.assertEqual(get_user_home(), '/Users/foobar')
+        assert get_user_home() == '/Users/foobar'
 
     @mock.patch.object(os, 'environ', {'HOME': '/home/foobar',
         'USERPROFILE': '/Users/foobar'})
     def test_prefers_home_over_userprofile(self):
-        self.assertEqual(get_user_home(), '/home/foobar')
+        assert get_user_home() == '/home/foobar'

kallithea/tests/vcs/test_utils_filesize.py

@@ -1,20 +1,19 b''
 from kallithea.lib.vcs.utils.filesize import filesizeformat
-from kallithea.lib.vcs.utils.compat import unittest
 
 
-class TestFilesizeformat(unittest.TestCase):
+class TestFilesizeformat(object):
 
     def test_bytes(self):
-        self.assertEqual(filesizeformat(10), '10 B')
+        assert filesizeformat(10) == '10 B'
 
     def test_kilobytes(self):
-        self.assertEqual(filesizeformat(1024 * 2), '2 KB')
+        assert filesizeformat(1024 * 2) == '2 KB'
 
     def test_megabytes(self):
-        self.assertEqual(filesizeformat(1024 * 1024 * 2.3), '2.3 MB')
+        assert filesizeformat(1024 * 1024 * 2.3) == '2.3 MB'
 
     def test_gigabytes(self):
-        self.assertEqual(filesizeformat(1024 * 1024 * 1024 * 12.92), '12.92 GB')
+        assert filesizeformat(1024 * 1024 * 1024 * 12.92) == '12.92 GB'
 
     def test_that_function_respects_sep_parameter(self):
-        self.assertEqual(filesizeformat(1, ''), '1B')
+        assert filesizeformat(1, '') == '1B'

kallithea/tests/vcs/test_vcs.py

@@ -1,7 +1,7 b''
 import os
 import shutil
 
-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 
 from kallithea.lib.utils2 import safe_str
 from kallithea.lib.vcs import VCSError, get_repo, get_backend
@@ -10,32 +10,33 b' from kallithea.lib.vcs.backends.hg impor'
 from kallithea.tests.vcs.conf import TEST_HG_REPO, TEST_GIT_REPO, TESTS_TMP_PATH
 
 
-class VCSTest(unittest.TestCase):
+class TestVCS(object):
     """
     Tests for main module's methods.
     """
 
     def test_get_backend(self):
         hg = get_backend('hg')
-        self.assertEqual(hg, MercurialRepository)
+        assert hg == MercurialRepository
 
     def test_alias_detect_hg(self):
         alias = 'hg'
         path = TEST_HG_REPO
         backend = get_backend(alias)
         repo = backend(safe_str(path))
-        self.assertEqual('hg', repo.alias)
+        assert 'hg' == repo.alias
 
     def test_alias_detect_git(self):
         alias = 'git'
         path = TEST_GIT_REPO
         backend = get_backend(alias)
         repo = backend(safe_str(path))
-        self.assertEqual('git', repo.alias)
+        assert 'git' == repo.alias
 
     def test_wrong_alias(self):
         alias = 'wrong_alias'
-        self.assertRaises(VCSError, get_backend, alias)
+        with pytest.raises(VCSError):
+            get_backend(alias)
 
     def test_get_repo(self):
         alias = 'hg'
@@ -43,8 +44,8 b' class VCSTest(unittest.TestCase):'
         backend = get_backend(alias)
         repo = backend(safe_str(path))
 
-        self.assertEqual(repo.__class__, get_repo(safe_str(path), alias).__class__)
-        self.assertEqual(repo.path, get_repo(safe_str(path), alias).path)
+        assert repo.__class__ == get_repo(safe_str(path), alias).__class__
+        assert repo.path == get_repo(safe_str(path), alias).path
 
     def test_get_repo_autoalias_hg(self):
         alias = 'hg'
@@ -52,8 +53,8 b' class VCSTest(unittest.TestCase):'
         backend = get_backend(alias)
         repo = backend(safe_str(path))
 
-        self.assertEqual(repo.__class__, get_repo(safe_str(path)).__class__)
-        self.assertEqual(repo.path, get_repo(safe_str(path)).path)
+        assert repo.__class__ == get_repo(safe_str(path)).__class__
+        assert repo.path == get_repo(safe_str(path)).path
 
     def test_get_repo_autoalias_git(self):
         alias = 'git'
@@ -61,8 +62,8 b' class VCSTest(unittest.TestCase):'
         backend = get_backend(alias)
         repo = backend(safe_str(path))
 
-        self.assertEqual(repo.__class__, get_repo(safe_str(path)).__class__)
-        self.assertEqual(repo.path, get_repo(safe_str(path)).path)
+        assert repo.__class__ == get_repo(safe_str(path)).__class__
+        assert repo.path == get_repo(safe_str(path)).path
 
     def test_get_repo_err(self):
         blank_repo_path = os.path.join(TESTS_TMP_PATH, 'blank-error-repo')
@@ -70,8 +71,10 b' class VCSTest(unittest.TestCase):'
             shutil.rmtree(blank_repo_path)
 
         os.mkdir(blank_repo_path)
-        self.assertRaises(VCSError, get_repo, blank_repo_path)
-        self.assertRaises(VCSError, get_repo, blank_repo_path + 'non_existing')
+        with pytest.raises(VCSError):
+            get_repo(blank_repo_path)
+        with pytest.raises(VCSError):
+            get_repo(blank_repo_path + 'non_existing')
 
     def test_get_repo_multialias(self):
         multialias_repo_path = os.path.join(TESTS_TMP_PATH, 'hg-git-repo')
@@ -82,4 +85,5 b' class VCSTest(unittest.TestCase):'
 
         os.mkdir(os.path.join(multialias_repo_path, '.git'))
         os.mkdir(os.path.join(multialias_repo_path, '.hg'))
-        self.assertRaises(VCSError, get_repo, multialias_repo_path)
+        with pytest.raises(VCSError):
+            get_repo(multialias_repo_path)