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
79
kallithea/tests/vcs/test_nodes.py
55
47
kallithea/tests/vcs/test_repository.py
25
30
kallithea/tests/vcs/test_tags.py
13
14
kallithea/tests/vcs/test_utils.py
61
68
kallithea/tests/vcs/test_utils_filesize.py
6
7
kallithea/tests/vcs/test_vcs.py
19
15
0 comments (0 inline, 0 general)
kallithea/tests/vcs/test_inmemchangesets.py
➞
Show inline comments
 
@@ -6,7 +6,7 @@ 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 @@ 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 @@ 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 @@ 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'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 = [

			




	
	
		
 
@@ -109,11 +115,11 @@ class InMemoryChangesetTestMixin(object)

			




	
	
	
		
 
        ]

			




	
	
	
		
 
        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)

			




	
	
		
 
@@ -128,28 +134,32 @@ 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 @@ class InMemoryChangesetTestMixin(object)

			




	
	
	
		
 
        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 = [

			




	
	
		
 
@@ -189,17 +198,16 @@ class InMemoryChangesetTestMixin(object)

			




	
	
	
		
 
                        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')

			




	
	
		
 
@@ -207,9 +215,8 @@ 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 @@ 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 @@ 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 @@ 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 @@ class InMemoryChangesetTestMixin(object)

			




	
	
	
		
 
        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.

			




	
	
	
		
 
    """

			




	
	
		
 
@@ -361,7 +383,7 @@ 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 @@ 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

			




	
	
		
 
@@ -10,7 +10,7 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    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

			




	
	
		
 
@@ -18,34 +18,30 @@ 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),

			




	
	
	
		
 
            '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):

			




	
	
		
 
@@ -86,16 +82,16 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ diff --git a/foobar3 b/foobar3

			




	
	
	
		
 
+FOOBAR

			




	
	
	
		
 
+FOOBAR

			




	
	
	
		
 
+FOOBAR

			




	
	
	
		
 
''')

			




	
	
	
		
 
'''

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
# For each backend create test case class

			




	
	
		
 
@@ -223,6 +219,5 @@ 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

			




	
	
		
 
@@ -14,20 +14,20 @@ 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 @@ 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 @@ 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
                    
                

        

        

            



	
	
		
 
@@ -6,7 +6,7 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 <username@example.com>",

			




	
	
	
		
 
                    ("Username Last'o'Name", "username@example.com")),

			




	
	
	
		
 
                  ("Username Last'o'Name Spaces < username@example.com >",

			




	
	
		
 
@@ -210,14 +204,14 @@ 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 @@ 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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    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

			




	
	
		
 
@@ -10,32 +10,33 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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)

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.