kallithea Changeset - 8f30206a15b5

Changeset - 8f30206a15b5

Parent rev.

Child rev.

[Not reviewed]

default

0 7 0

Branko Majic (branko) - 8 years ago 2018-02-03 11:12:13
branko@majic.rs

Grafted from: 8290cd74360e

tests: convert remaining vcs tests to py.test

7 files changed with 279 insertions and 260 deletions:

kallithea/tests/vcs/test_inmemchangesets.py

100

kallithea/tests/vcs/test_nodes.py

kallithea/tests/vcs/test_repository.py

kallithea/tests/vcs/test_tags.py

kallithea/tests/vcs/test_utils.py

kallithea/tests/vcs/test_utils_filesize.py

kallithea/tests/vcs/test_vcs.py

0 comments (0 inline, 0 general)

kallithea/tests/vcs/test_inmemchangesets.py

➞

Show inline comments

 # encoding: utf8
 """
 Tests so called "in memory changesets" commit API of vcs.
 """
 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
 from kallithea.lib.vcs.exceptions import NodeAlreadyAddedError
 from kallithea.lib.vcs.exceptions import NodeAlreadyExistsError
 from kallithea.lib.vcs.exceptions import NodeAlreadyRemovedError
 from kallithea.lib.vcs.exceptions import NodeAlreadyChangedError
 from kallithea.lib.vcs.exceptions import NodeDoesNotExistError
 from kallithea.lib.vcs.exceptions import NodeNotChangedError
 from kallithea.lib.vcs.nodes import DirNode
 from kallithea.lib.vcs.nodes import FileNode
 from kallithea.lib.vcs.utils import safe_unicode
@@ @@ -29,312 +29,334 @@ class InMemoryChangesetTestMixin(object) @@
     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
     """
     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)
         self.imc = self.repo.in_memory_changeset
         self.nodes = [
             FileNode('foobar', content='Foo & bar'),
             FileNode('foobar2', content='Foo & bar, doubled!'),
             FileNode('foo bar with spaces', content=''),
             FileNode('foo/bar/baz', content='Inside'),
             FileNode('foo/bar/file.bin', content='\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x03\x00\xfe\xff\t\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x18\x00\x00\x00\x01\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'),
+        ]
     def test_add(self):
         rev_count = len(self.repo.revisions)
         to_add = [FileNode(node.path, content=node.content)
             for node in self.nodes]
         for node in to_add:
             self.imc.add(node)
         message = u'Added: %s' % ', '.join((node.path for node in self.nodes))
         author = unicode(self.__class__)
         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)
         to_add = [FileNode(node.path, content=node.content)
             for node in self.nodes]
         self.imc.add(*to_add)
         message = u'Added: %s' % ', '.join((node.path for node in self.nodes))
         author = unicode(self.__class__)
         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'joe.doe@example.com')
         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 = [
             FileNode('foo/bar/foobaz/bar', content='foo'),
             FileNode('foo/bar/another/bar', content='foo'),
             FileNode('foo/baz.txt', content='foo'),
             FileNode('foobar/foobaz/file', content='foo'),
             FileNode('foobar/barbaz', content='foo'),
+        ]
         self.imc.add(*to_add)
         changeset = self.imc.commit(u'Another', u'joe.doe@example.com')
         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)
         to_add = [
             FileNode('żółwik/zwierzątko', content='ćććć'),
             FileNode(u'żółwik/zwierzątko_uni', content=u'ćććć'),
+        ]
         for node in to_add:
             self.imc.add(node)
         message = u'Added: %s' % ', '.join((node.path for node in self.nodes))
         author = unicode(self.__class__)
         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'))
         self.imc.add(FileNode('foo/fbar', content='foobar'))
         tip = self.imc.commit(u'Initial', u'joe.doe@example.com')
         # Change node's content
         node = FileNode('foo/bar/baz', content='My **changed** content')
         self.imc.change(node)
         self.imc.commit(u'Changed %s' % node.path, u'joe.doe@example.com')
         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 = [
             FileNode('żółwik/zwierzątko', content='ćććć'),
             FileNode(u'żółwik/zwierzątko_uni', content=u'ćććć'),
+        ]
         for node in to_add:
             self.imc.add(node)
         tip = self.imc.commit(u'Initial', u'joe.doe@example.com')
         # Change node's content
         node = FileNode('żółwik/zwierzątko', content='My **changed** content')
         self.imc.change(node)
         self.imc.commit(u'Changed %s' % safe_unicode(node.path),
                         u'joe.doe@example.com')
         node = FileNode(u'żółwik/zwierzątko_uni', content=u'My **changed** content')
         self.imc.change(node)
         self.imc.commit(u'Changed %s' % safe_unicode(node.path),
                         u'joe.doe@example.com')
         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')
         self.imc.add(node)
         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')
         self.imc.add(node)
         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')
         self.imc.add(node)
         self.imc.commit(u'added', u'joe doe')
         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
         last = None
         for x in xrange(N):
             fname = 'file%s' % str(x).rjust(5, '0')
             content = 'foobar\n' * x
             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!')
         self.imc.add(node)
         date = datetime.datetime(1985, 1, 30, 1, 45)
         commit = self.imc.commit(u"Committed at time when I was born ;-)",
             author=u'lb <lb@example.com>', 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.
     """
     backend_alias = 'hg'
     commits = [
+        {
             'message': 'Initial commit',
             'author': 'Joe Doe <joe.doe@example.com>',
             'date': datetime.datetime(2010, 1, 1, 20),
             'added': [
                 FileNode('foobar', content='Foobar'),
                 FileNode('foobar2', content='Foobar II'),
@@ @@ -352,25 +374,25 @@ class BackendBaseTestCase(unittest.TestC @@
         """
         if hasattr(self, 'commits'):
             return self.commits
     def get_new_repo_path(self):
         """
         Returns newly created repository's directory.
         """
         key = '%s-%s' % (self.backend_alias, str(time.time()))
         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()
         self.repo = Backend(self.repo_path, create=True)
         self.imc = self.repo.in_memory_changeset
         for commit in self.get_commits():
             for node in commit.get('added', []):
                 self.imc.add(FileNode(node.path, content=node.content))
             for node in commit.get('changed', []):
                 self.imc.change(FileNode(node.path, content=node.content))
             for node in commit.get('removed', []):
@@ @@ -378,15 +400,14 @@ class BackendBaseTestCase(unittest.TestC @@
             self.imc.commit(message=unicode(commit['message']),
                             author=unicode(commit['author']),
                 date=commit['date'])
         self.tip = self.repo.get_changeset()
 # For each backend create test case class
 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

➞

Show inline comments

 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
 from kallithea.lib.vcs.nodes import Node
 from kallithea.lib.vcs.nodes import NodeError
 from kallithea.lib.vcs.nodes import NodeKind
-class NodeBasicTest(unittest.TestCase):
+class TestNodeBasic(object):
     def test_init(self):
         """
         Cannot initialize Node objects with path with slash at the beginning.
         """
         wrong_paths = (
             '/foo',
             '/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):
         """
         Tests if node's parent path are properly computed.
         """
         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 = (
             # (node_path, expected_parent_path)
             ('', ''),
             ('some/path/', 'some/'),
             ('some/longer/path/', 'some/longer/'),
+        )
         for node_path, expected_parent_path in test_paths:
             self._test_parent_path(node_path, expected_parent_path)
     '''
     def _test_trailing_slash(self, path):
         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/'):
             self._test_trailing_slash(path)
     '''
     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 = [
             DirNode('docs'),
             DirNode('tests'),
             FileNode('bar'),
             FileNode('foo'),
             FileNode('readme.txt'),
             FileNode('setup.py'),
+        ]
         dirnode = DirNode('', nodes=nodes)
         for node in dirnode:
             node == dirnode.get_node(node.path)
     def test_node_state(self):
         """
         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')
         tar_node = FileNode('test.tar.gz')
         my_node2 = FileNode('myfile2')
         my_node2._content = 'foobar'
         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

➞

Show inline comments

 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
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS
 from kallithea.tests.vcs import TEST_USER_CONFIG_FILE
 class RepositoryBaseTest(_BackendTestMixin):
     recreate_repo_per_test = False
     @classmethod
     def _get_commits(cls):
         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),
             'foo.bar@example.com')
         assert self.repo.get_user_email(TEST_USER_CONFIG_FILE) == 'foo.bar@example.com'
     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):
     @classmethod
     def _get_commits(cls):
         commits = [
+            {
                 'message': 'Initial commit',
                 'author': 'Joe Doe <joe.doe@example.com>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
@@ @@ -77,152 +73,151 @@ class RepositoryGetDiffTest(_BackendTest @@
                 'message': 'Removed foobar, changed foobar3',
                 'author': 'Jane Doe <jane.doe@example.com>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'changed': [
                     FileNode('foobar3', content='FOOBAR\nFOOBAR\nFOOBAR\n'),
                 ],
                 'removed': [FileNode('foobar')],
             },
+        ]
         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
 +++ b/foobar
@@ -0,0 +1 @@
 +foobar
 \ No newline at end of file
 diff --git a/foobar2 b/foobar2
 new file mode 100644
 index 0000000000000000000000000000000000000000..e8c9d6b98e3dce993a464935e1a53f50b56a3783
 --- /dev/null
 +++ b/foobar2
@@ -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
@@ -1 +1 @@
 -foobar
 \ No newline at end of file
 +FOOBAR
 \ No newline at end of file
 diff --git a/foobar3 b/foobar3
 new file mode 100644
 index 0000000000000000000000000000000000000000..c11c37d41d33fb47741cff93fa5f9d798c1535b0
 --- /dev/null
 +++ b/foobar3
@@ -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
 +++ /dev/null
@@ -1 +0,0 @@
 -FOOBAR
 \ No newline at end of file
 diff --git a/foobar3 b/foobar3
 index c11c37d41d33fb47741cff93fa5f9d798c1535b0..f9324477362684ff692aaf5b9a81e01b9e9a671c 100644
 --- a/foobar3
 +++ b/foobar3
@@ -1 +1,3 @@
 -foobar3
 \ No newline at end of file
 +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
@@ -0,0 +1,1 @@
 +foobar
 \ No newline at end of file
 diff --git a/foobar2 b/foobar2
 new file mode 100644
 --- /dev/null
 +++ b/foobar2
@@ -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 @@
 -foobar
 \ No newline at end of file
 +FOOBAR
 \ No newline at end of file
 diff --git a/foobar3 b/foobar3
 new file mode 100644
 --- /dev/null
 +++ b/foobar3
@@ -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
@@ -1,1 +0,0 @@
 -FOOBAR
 \ No newline at end of file
 diff --git a/foobar3 b/foobar3
 --- a/foobar3
 +++ b/foobar3
@@ -1,1 +1,3 @@
 -foobar3
 \ No newline at end of file
 +FOOBAR
 +FOOBAR
 +FOOBAR
-''')
 '''
 # For each backend create test case class
 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

➞

Show inline comments

-from kallithea.lib.vcs.utils.compat import unittest
+import pytest
 from kallithea.lib.vcs.exceptions import TagAlreadyExistError
 from kallithea.lib.vcs.exceptions import TagDoesNotExistError
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS
 class TagsTestCaseMixin(_BackendTestMixin):
     def test_new_tag(self):
         tip = self.repo.get_changeset()
         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()
         self.repo.tag('last-commit', 'joe', tip.raw_id)
         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
 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

➞

Show inline comments

 # -*- coding: utf-8 -*-
 import os
 import mock
 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
 from kallithea.lib.vcs.utils.helpers import get_scm
 from kallithea.lib.vcs.utils.helpers import get_scms_for_path
 from kallithea.lib.vcs.utils.helpers import get_total_seconds
 from kallithea.lib.vcs.utils.helpers import parse_changesets
 from kallithea.lib.vcs.utils.helpers import parse_datetime
 from kallithea.lib.vcs.utils import author_email, author_name
 from kallithea.lib.vcs.utils.paths import get_user_home
 from kallithea.lib.vcs.exceptions import VCSError
 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):
         """
         Tests if get_dirs_for_path returns same as expected.
         """
         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'
         paths_and_results = (
             ('foo/bar/baz/file', ['foo', 'foo/bar', 'foo/bar/baz']),
             ('foo/bar/', ['foo', 'foo/bar']),
             ('foo/bar', ['foo']),
+        )
         for path, expected in paths_and_results:
             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')
         if os.path.isdir(multialias_repo_path):
             shutil.rmtree(multialias_repo_path)
         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 <username@example.com>",
                     ("Username Last'o'Name", "username@example.com")),
                   ("Username Last'o'Name Spaces < username@example.com >",
                     ("Username Last'o'Name Spaces", "username@example.com")),
                   ("Username Last'o'Name <username.lastname@example.com>",
                     ("Username Last'o'Name", "username.lastname@example.com")),
                   ('mrf RFC_SPEC <username+lastname@example.com>',
                     ('mrf RFC_SPEC', 'username+lastname@example.com')),
                   ('username <user@example.com>',
                     ('username', 'user@example.com')),
                   ('username <user@example.com',
                    ('username', 'user@example.com')),
@@ @@ -201,73 +195,72 @@ class TestAuthorExtractors(unittest.Test @@
                   ('<justemail@example.com>',
                    ('', 'justemail@example.com')),
                   ('justname',
                    ('justname', '')),
                   ('Mr Double Name withemail@example.com ',
                    ('Mr Double Name', 'withemail@example.com')),
                   (u'John Doe <джондо à éẋàṁṗłê.ç°ḿ>',
                    (u'John Doe <\u0434\u0436\u043e\u043d\u0434\u043e \xe0 \xe9\u1e8b\xe0\u1e41\u1e57\u0142\xea.\xe7\xb0\u1e3f>', '')),
+                  ]
     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()
         obj.NOT_INCLUDED = 'this key/value should not be included'
         obj.CONST = True
         obj.foo = 'aaa'
         obj.attrs = {'foo': 'bar'}
         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)
     def test_get_total_seconds_returns_proper_value_for_partial_seconds(self):
         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

➞

Show inline comments

 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

➞

Show inline comments

 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
 from kallithea.lib.vcs.backends.hg import MercurialRepository
 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'
         path = TEST_HG_REPO
         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'
         path = TEST_HG_REPO
         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'
         path = TEST_GIT_REPO
         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')
         if os.path.isdir(blank_repo_path):
             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')
         if os.path.isdir(multialias_repo_path):
             shutil.rmtree(multialias_repo_path)
         os.mkdir(multialias_repo_path)
         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)

0 comments (0 inline, 0 general)