kallithea Changeset - 45a281a0f36f

Changeset - 45a281a0f36f

Parent rev.

Child rev.

[Not reviewed]

default

0 14 0

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

Grafted from: b3354d6572cc

tests: Remove metaprogramming constructs for vcs test classes (issue #309):

- Removed use of the globals() and type() constructs to
programatically instantiate Git/Mercurial-specific test
classes. This should make it a bit clearer what tests are being run
at the expense of possible future VCS additions.
- Removed the SCM_TESTS VCS test configuration variable, since it got
removed. Previously it was used for instantiating test classes.
- Updated small snippet of inline documentation that described the use
of SCM_TESTS variable. New text points to inheriting from generic
test classes instead.
- base.py had a dead snippet - kill it.

14 files changed with 90 insertions and 107 deletions:

kallithea/tests/base.py

kallithea/tests/vcs/__init__.py

kallithea/tests/vcs/base.py

kallithea/tests/vcs/conf.py

kallithea/tests/vcs/test_archives.py

kallithea/tests/vcs/test_branches.py

kallithea/tests/vcs/test_changesets.py

kallithea/tests/vcs/test_filenodes_unicode_path.py

kallithea/tests/vcs/test_getitem.py

kallithea/tests/vcs/test_getslice.py

kallithea/tests/vcs/test_inmemchangesets.py

kallithea/tests/vcs/test_repository.py

kallithea/tests/vcs/test_tags.py

kallithea/tests/vcs/test_workdirs.py

0 comments (0 inline, 0 general)

kallithea/tests/base.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
+#
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import datetime
 import logging
 import os
 import pytest
 import re
 import tempfile
 import time
 from tg import config
 from webtest import TestApp
 from kallithea import model
 from kallithea.model.db import Notification, User, UserNotification
 from kallithea.model.meta import Session
 from kallithea.lib.utils2 import safe_str
 log = logging.getLogger(__name__)
 skipif = pytest.mark.skipif
 parametrize = pytest.mark.parametrize
 # Hack: These module global values MUST be set to actual values before running any tests. This is currently done by conftest.py.
 url = None
 testapp = None
 __all__ = [
     'skipif', 'parametrize', 'url', 'TestController',
     'ldap_lib_installed', 'pam_lib_installed', 'invalidate_all_caches',
     'TESTS_TMP_PATH', 'HG_REPO', 'GIT_REPO', 'NEW_HG_REPO', 'NEW_GIT_REPO',
     'HG_FORK', 'GIT_FORK', 'TEST_USER_ADMIN_LOGIN', 'TEST_USER_ADMIN_PASS',
     'TEST_USER_ADMIN_EMAIL', 'TEST_USER_REGULAR_LOGIN', 'TEST_USER_REGULAR_PASS',
     'TEST_USER_REGULAR_EMAIL', 'TEST_USER_REGULAR2_LOGIN',
     'TEST_USER_REGULAR2_PASS', 'TEST_USER_REGULAR2_EMAIL', 'TEST_HG_REPO',
     'TEST_HG_REPO_CLONE', 'TEST_HG_REPO_PULL', 'TEST_GIT_REPO',
     'TEST_GIT_REPO_CLONE', 'TEST_GIT_REPO_PULL', 'HG_REMOTE_REPO',
-    'GIT_REMOTE_REPO', 'SCM_TESTS', 'HG_TEST_REVISION', 'GIT_TEST_REVISION',
     'GIT_REMOTE_REPO', 'HG_TEST_REVISION', 'GIT_TEST_REVISION',
+]
 # Invoke websetup with the current config file
 # SetupCommand('setup-app').run([config_file])
 ## SOME GLOBALS FOR TESTS
 TESTS_TMP_PATH = os.environ.get('KALLITHEA_TESTS_TMP_PATH', tempfile.mkdtemp(prefix='kallithea-test-'))
 TEST_USER_ADMIN_LOGIN = 'test_admin'
 TEST_USER_ADMIN_PASS = 'test12'
 TEST_USER_ADMIN_EMAIL = 'test_admin@example.com'
 TEST_USER_REGULAR_LOGIN = 'test_regular'
 TEST_USER_REGULAR_PASS = 'test12'
 TEST_USER_REGULAR_EMAIL = 'test_regular@example.com'
 TEST_USER_REGULAR2_LOGIN = 'test_regular2'
 TEST_USER_REGULAR2_PASS = 'test12'
 TEST_USER_REGULAR2_EMAIL = 'test_regular2@example.com'
 HG_REPO = u'vcs_test_hg'
 GIT_REPO = u'vcs_test_git'
 NEW_HG_REPO = u'vcs_test_hg_new'
 NEW_GIT_REPO = u'vcs_test_git_new'
 HG_FORK = u'vcs_test_hg_fork'
 GIT_FORK = u'vcs_test_git_fork'
 HG_TEST_REVISION = u"a53d9201d4bc278910d416d94941b7ea007ecd52"
 GIT_TEST_REVISION = u"7ab37bc680b4aa72c34d07b230c866c28e9fc204"
 ## VCS
 SCM_TESTS = ['hg', 'git']
 uniq_suffix = str(int(time.mktime(datetime.datetime.now().timetuple())))
 GIT_REMOTE_REPO = os.path.join(TESTS_TMP_PATH, GIT_REPO)
 TEST_GIT_REPO = os.path.join(TESTS_TMP_PATH, GIT_REPO)
 TEST_GIT_REPO_CLONE = os.path.join(TESTS_TMP_PATH, 'vcs-git-clone-%s' % uniq_suffix)
 TEST_GIT_REPO_PULL = os.path.join(TESTS_TMP_PATH, 'vcs-git-pull-%s' % uniq_suffix)
 HG_REMOTE_REPO = os.path.join(TESTS_TMP_PATH, HG_REPO)
 TEST_HG_REPO = os.path.join(TESTS_TMP_PATH, HG_REPO)
 TEST_HG_REPO_CLONE = os.path.join(TESTS_TMP_PATH, 'vcs-hg-clone-%s' % uniq_suffix)
 TEST_HG_REPO_PULL = os.path.join(TESTS_TMP_PATH, 'vcs-hg-pull-%s' % uniq_suffix)
 # By default, some of the tests will utilise locally available
 # repositories stored within tar.gz archives as source for
 # cloning. Should you wish to use some other, remote archive, simply
 # uncomment these entries and/or update the URLs to use.
+#
 # GIT_REMOTE_REPO = 'git://github.com/codeinn/vcs.git'
 # HG_REMOTE_REPO = 'http://bitbucket.org/marcinkuzminski/vcs'
 # skip ldap tests if LDAP lib is not installed
 ldap_lib_installed = False
 try:
     import ldap
     ldap.API_VERSION
     ldap_lib_installed = True
 except ImportError:
     # means that python-ldap is not installed
     pass
 try:
     import pam
     pam.PAM_TEXT_INFO
     pam_lib_installed = True
 except ImportError:
     pam_lib_installed = False
 def invalidate_all_caches():
     """Invalidate all beaker caches currently configured.
     Useful when manipulating IP permissions in a test and changes need to take
     effect immediately.
     Note: Any use of this function is probably a workaround - it should be
     replaced with a more specific cache invalidation in code or test."""
     from beaker.cache import cache_managers
     for cache in cache_managers.values():
         cache.clear()
 class NullHandler(logging.Handler):
     def emit(self, record):
         pass
 class TestController(object):
     """Pytest-style test controller"""
     # Note: pytest base classes cannot have an __init__ method
     @pytest.fixture(autouse=True)
     def app_fixture(self):
         h = NullHandler()
         logging.getLogger("kallithea").addHandler(h)
         self.app = TestApp(testapp)
         return self.app
     def remove_all_notifications(self):
         # query().delete() does not (by default) trigger cascades
         # ( http://docs.sqlalchemy.org/en/rel_0_7/orm/collections.html#passive-deletes )
         # so delete the UserNotification first to ensure referential integrity.
         UserNotification.query().delete()
         Notification.query().delete()
         Session().commit()
     def log_user(self, username=TEST_USER_ADMIN_LOGIN,
                  password=TEST_USER_ADMIN_PASS):
         self._logged_username = username
         response = self.app.post(url(controller='login', action='index'),
                                  {'username': username,
                                   'password': password})
         if 'Invalid username or password' in response.body:
             pytest.fail('could not login using %s %s' % (username, password))
         assert response.status == '302 Found'
         self.assert_authenticated_user(response, username)
         response = response.follow()
         return response.session['authuser']
     def _get_logged_user(self):
         return User.get_by_username(self._logged_username)

kallithea/tests/vcs/__init__.py

➞

Show inline comments

 """
 Unit tests for vcs_ library.
 In order to run tests we need to prepare our environment first. Tests would be
 run for each engine listed at ``conf.SCM_TESTS`` - keys are aliases from
 ``vcs.backends.BACKENDS``.
 While some tests are implemented for a specific backend, a huge number
 is completely independent of the underlying backend.
 For such independent tests a base testing class is implemented, and
 backend-specific test classes are defined. These sub-classes simply
 need to set the correct backend to use by setting the
 ``backend_alias`` property, which should correspond to one of the keys
 from ``vcs.backends.BACKENDS``.
 For each SCM we run tests for, we need some repository. We would use
 repositories location provided in test suite defaults - see ``conf``
 module for more detail. We simply try to check if repository at
 certain location exists, if not we would try to fetch them. At
 ``test_vcs`` or ``test_common`` we run unit tests common for each
 repository type and for example specific mercurial tests are located
 at ``test_hg`` module.
 """
 import os
 import shutil
 from kallithea.tests.base import TEST_HG_REPO, HG_REMOTE_REPO, TEST_GIT_REPO, GIT_REMOTE_REPO, TESTS_TMP_PATH
 from kallithea.tests.vcs.utils import SCMFetcher
 # Base directory for the VCS tests.
 VCS_TEST_MODULE_BASE_DIR = os.path.abspath(os.path.dirname(__file__))
 # Path to user configuration file used during tests.
 TEST_USER_CONFIG_FILE = os.path.join(TESTS_TMP_PATH, 'aconfig')
 def setup_package():
     """
     Prepares whole package for tests which mainly means it would try to fetch
     test repositories or use already existing ones.
     """
     fetchers = {
         'hg': {
             'alias': 'hg',
             'test_repo_path': TEST_HG_REPO,
             'remote_repo': HG_REMOTE_REPO,
             'clone_cmd': 'hg clone --insecure',
         },
         'git': {
             'alias': 'git',
             'test_repo_path': TEST_GIT_REPO,
             'remote_repo': GIT_REMOTE_REPO,
             'clone_cmd': 'git clone --bare',
         },
+    }
     for scm, fetcher_info in fetchers.items():
         fetcher = SCMFetcher(**fetcher_info)
         fetcher.setup()
     # Copy the test user configuration file to location where
     # temporary test data is stored at.
     shutil.copy(os.path.join(VCS_TEST_MODULE_BASE_DIR, 'aconfig'), TEST_USER_CONFIG_FILE)

kallithea/tests/vcs/base.py

➞

Show inline comments

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

kallithea/tests/vcs/conf.py

➞

Show inline comments

 """
 Unit tests configuration module for vcs.
 """
 import os
 import uuid
 # Retrieve the necessary configuration options from the test base
 # module. Some of these configuration options are subsequently
 # consumed by the VCS test module.
 from kallithea.tests.base import (
-    TESTS_TMP_PATH, SCM_TESTS,
     TESTS_TMP_PATH,
     TEST_HG_REPO, HG_REMOTE_REPO,
     TEST_HG_REPO_CLONE, TEST_HG_REPO_PULL,
     TEST_GIT_REPO, GIT_REMOTE_REPO,
     TEST_GIT_REPO_CLONE,
+)
 __all__ = (
     'TEST_HG_REPO', 'TEST_GIT_REPO', 'HG_REMOTE_REPO', 'GIT_REMOTE_REPO',
     'TEST_HG_REPO_CLONE', 'TEST_GIT_REPO_CLONE', 'TEST_HG_REPO_PULL',
     'SCM_TESTS',
+)
 def get_new_dir(title=None):
     """
     Calculates a path for a new, non-existant, unique sub-directory in TESTS_TMP_PATH.
     Resulting directory name will have format:
     vcs-test-[title-]hexuuid
     The "hexuuid" is a hexadecimal value of a randomly generated
     UUID. Title will be added if specified.
     Args:
         title: Custom title to include as part of the resulting sub-directory
             name. Can be useful for debugging to identify destination. Defaults
             to None.
     Returns:
         Path to the new directory as a string.
     """
     test_repo_prefix = 'vcs-test'
     if title:
         name = "%s-%s" % (test_repo_prefix, title)
     else:
         name = test_repo_prefix
     path = os.path.join(TESTS_TMP_PATH, name)
     # Generate new hexes until we get a unique name (just in case).
     hex_uuid = uuid.uuid4().hex
     while os.path.exists("%s-%s" % (path, hex_uuid)):
         hex_uuid = uuid.uuid4().hex
     return "%s-%s" % (path, hex_uuid)

kallithea/tests/vcs/test_archives.py

➞

Show inline comments

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

kallithea/tests/vcs/test_branches.py

➞

Show inline comments

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

kallithea/tests/vcs/test_changesets.py

➞

Show inline comments

 # encoding: utf8
 import time
 import datetime
 import pytest
 from kallithea.lib import vcs
 from kallithea.lib.vcs.backends.base import BaseChangeset
 from kallithea.lib.vcs.nodes import (
     FileNode, AddedFileNodesGenerator,
     ChangedFileNodesGenerator, RemovedFileNodesGenerator
+)
 from kallithea.lib.vcs.exceptions import (
     BranchDoesNotExistError, ChangesetDoesNotExistError,
     RepositoryError, EmptyRepositoryError
+)
 from kallithea.tests.vcs.base import _BackendTestMixin
-from kallithea.tests.vcs.conf import SCM_TESTS, get_new_dir
 from kallithea.tests.vcs.conf import get_new_dir
 class TestBaseChangeset(object):
     def test_as_dict(self):
         changeset = BaseChangeset()
         changeset.id = 'ID'
         changeset.raw_id = 'RAW_ID'
         changeset.short_id = 'SHORT_ID'
         changeset.revision = 1009
         changeset.date = datetime.datetime(2011, 1, 30, 1, 45)
         changeset.message = 'Message of a commit'
         changeset.author = 'Joe Doe <joe.doe@example.com>'
         changeset.added = [FileNode('foo/bar/baz'), FileNode(u'foobar'), FileNode(u'blåbærgrød')]
         changeset.changed = []
         changeset.removed = []
         assert changeset.as_dict() == {
             'id': 'ID',
             'raw_id': 'RAW_ID',
             'short_id': 'SHORT_ID',
             'revision': 1009,
             'date': datetime.datetime(2011, 1, 30, 1, 45),
             'message': 'Message of a commit',
             'author': {
                 'name': 'Joe Doe',
                 'email': 'joe.doe@example.com',
             },
             'added': ['foo/bar/baz', 'foobar', u'bl\xe5b\xe6rgr\xf8d'],
             'changed': [],
             'removed': [],
+        }
 class _ChangesetsWithCommitsTestCaseixin(_BackendTestMixin):
     recreate_repo_per_test = True
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': 'Commit %d' % x,
                 'author': 'Joe Doe <joe.doe@example.com>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
+            }
     def test_new_branch(self):
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
+        )
         assert 'foobar' in self.repo.branches
         assert foobar_tip.branch == 'foobar'
         assert foobar_tip.branches == ['foobar']
         # 'foobar' should be the only branch that contains the new commit
         branch_tips = self.repo.branches.values()
         assert branch_tips.count(str(foobar_tip.raw_id)) == 1
     def test_new_head_in_default_branch(self):
         tip = self.repo.get_changeset()
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
             parents=[tip],
+        )
         self.imc.change(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\nand more...\n'))
         newtip = self.imc.commit(
             message=u'At default branch',
             author=u'joe',
             branch=foobar_tip.branch,
             parents=[foobar_tip],
+        )
         newest_tip = self.imc.commit(
             message=u'Merged with %s' % foobar_tip.raw_id,
             author=u'joe',
             branch=self.backend_class.DEFAULT_BRANCH_NAME,
             parents=[newtip, foobar_tip],
+        )
         assert newest_tip.branch == self.backend_class.DEFAULT_BRANCH_NAME
         assert newest_tip.branches == [self.backend_class.DEFAULT_BRANCH_NAME]
     def test_get_changesets_respects_branch_name(self):
         tip = self.repo.get_changeset()
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
@@ @@ -281,112 +281,118 @@ class _ChangesetsTestCaseMixin(_BackendT @@
         with pytest.raises(ChangesetDoesNotExistError):
             list(self.repo.get_changesets(end='foobar'))
     def test_get_changesets_raise_branchdoesnotexist_for_wrong_branch_name(self):
         with pytest.raises(BranchDoesNotExistError):
             list(self.repo.get_changesets(branch_name='foobar'))
     def test_get_changesets_raise_repositoryerror_for_wrong_start_end(self):
         start = self.repo.revisions[-1]
         end = self.repo.revisions[0]
         with pytest.raises(RepositoryError):
             list(self.repo.get_changesets(start=start, end=end))
     def test_get_changesets_numerical_id_reversed(self):
         with pytest.raises(RepositoryError):
             [x for x in self.repo.get_changesets(start=3, end=2)]
     def test_get_changesets_numerical_id_respects_both_start_and_end_last(self):
         with pytest.raises(RepositoryError):
             last = len(self.repo.revisions)
             list(self.repo.get_changesets(start=last-1, end=last-2))
     def test_get_changesets_numerical_id_last_zero_error(self):
         with pytest.raises(RepositoryError):
             last = len(self.repo.revisions)
             list(self.repo.get_changesets(start=last-1, end=0))
 class _ChangesetsChangesTestCaseMixin(_BackendTestMixin):
     recreate_repo_per_test = False
     @classmethod
     def _get_commits(cls):
         return [
+            {
                 'message': u'Initial',
                 'author': u'Joe Doe <joe.doe@example.com>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foo/bar', content='foo'),
                     FileNode('foo/bał', content='foo'),
                     FileNode('foobar', content='foo'),
                     FileNode('qwe', content='foo'),
                 ],
             },
+            {
                 'message': u'Massive changes',
                 'author': u'Joe Doe <joe.doe@example.com>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'added': [FileNode('fallout', content='War never changes')],
                 'changed': [
                     FileNode('foo/bar', content='baz'),
                     FileNode('foobar', content='baz'),
                 ],
                 'removed': [FileNode('qwe')],
             },
+        ]
     def test_initial_commit(self):
         changeset = self.repo.get_changeset(0)
         assert sorted(list(changeset.added)) == sorted([
             changeset.get_node('foo/bar'),
             changeset.get_node('foo/bał'),
             changeset.get_node('foobar'),
             changeset.get_node('qwe'),
         ])
         assert list(changeset.changed) == []
         assert list(changeset.removed) == []
         assert u'foo/ba\u0142' in changeset.as_dict()['added']
         assert u'foo/ba\u0142' in changeset.__json__(with_file_list=True)['added']
     def test_head_added(self):
         changeset = self.repo.get_changeset()
         assert isinstance(changeset.added, AddedFileNodesGenerator)
         assert list(changeset.added) == [
             changeset.get_node('fallout'),
+        ]
         assert isinstance(changeset.changed, ChangedFileNodesGenerator)
         assert list(changeset.changed) == [
             changeset.get_node('foo/bar'),
             changeset.get_node('foobar'),
+        ]
         assert isinstance(changeset.removed, RemovedFileNodesGenerator)
         assert len(changeset.removed) == 1
         assert list(changeset.removed)[0].path == 'qwe'
     def test_get_filemode(self):
         changeset = self.repo.get_changeset()
         assert 33188 == changeset.get_file_mode('foo/bar')
     def test_get_filemode_non_ascii(self):
         changeset = self.repo.get_changeset()
         assert 33188 == changeset.get_file_mode('foo/bał')
         assert 33188 == changeset.get_file_mode(u'foo/bał')
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
+    }
     # tests with additional commits
     cls_name = 'Test' + alias.title() + 'ChangesetsWithCommits'
     globals()[cls_name] = type(cls_name, (_ChangesetsWithCommitsTestCaseixin,), attrs)
 class TestGitChangesetsWithCommits(_ChangesetsWithCommitsTestCaseixin):
     backend_alias = 'git'
 class TestGitChangesets(_ChangesetsTestCaseMixin):
     backend_alias = 'git'
 class TestGitChangesetsChanges(_ChangesetsChangesTestCaseMixin):
     backend_alias = 'git'
     # tests without additional commits
     cls_name = 'Test' + alias.title() + 'Changesets'
     globals()[cls_name] = type(cls_name, (_ChangesetsTestCaseMixin,), attrs)
 class TestHgChangesetsWithCommits(_ChangesetsWithCommitsTestCaseixin):
     backend_alias = 'hg'
     # tests changes
     cls_name = 'Test' + alias.title() + 'ChangesetsChanges'
     globals()[cls_name] = type(cls_name, (_ChangesetsChangesTestCaseMixin,), attrs)
 class TestHgChangesets(_ChangesetsTestCaseMixin):
     backend_alias = 'hg'
 class TestHgChangesetsChanges(_ChangesetsChangesTestCaseMixin):
     backend_alias = 'hg'

kallithea/tests/vcs/test_filenodes_unicode_path.py

➞

Show inline comments

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

kallithea/tests/vcs/test_getitem.py

➞

Show inline comments

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

kallithea/tests/vcs/test_getslice.py

➞

Show inline comments

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

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
 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
-from kallithea.tests.vcs.conf import SCM_TESTS, get_new_dir
 from kallithea.tests.vcs.conf import get_new_dir
 class InMemoryChangesetTestMixin(object):
     """
     This is a backend independent test case class which should be created
     with ``type`` method.
     It is required to set following attributes at subclass:
     - ``backend_alias``: alias of used backend (see ``vcs.BACKENDS``)
     - ``repo_path``: path to the repository which would be created for set of
       tests
     """
     def get_backend(self):
         return vcs.get_backend(self.backend_alias)
     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()
         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:
             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()
         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:
             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')
         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')
         changeset.get_node('foo/bar/foobaz/bar').content == 'foo'
         changeset.get_node('foo/bar/another/bar').content == 'foo'
@@ @@ -311,103 +311,102 @@ class InMemoryChangesetTestMixin(object) @@
         #self.imc.change(FileNode('baz', content='new'))
         #self.imc.remove(FileNode('qwe'))
         self.imc.reset()
         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')
             assert last != commit
             last = commit
         # Check commit number for same repo
         assert len(self.repo.revisions) == N
         # Check commit number for recreated repo
         backend = self.get_backend()
         repo = backend(self.repo_path)
         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)
         assert commit.date == date
 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'),
                 FileNode('foo/bar/baz', content='baz here!'),
             ],
         },
+    ]
     def get_backend(self):
         return vcs.get_backend(self.backend_alias)
     def get_commits(self):
         """
         Returns list of commits which builds repository for each tests.
         """
         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_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', []):
                 self.imc.remove(FileNode(node.path))
             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(('test %s in memory changeset' % alias).title().split())
     globals()[cls_name] = type(cls_name, (InMemoryChangesetTestMixin,), attrs)
 class TestGitInMemoryChangeset(InMemoryChangesetTestMixin):
     backend_alias = 'git'
 class TestHgInMemoryChangeset(InMemoryChangesetTestMixin):
     backend_alias = 'hg'

kallithea/tests/vcs/test_repository.py

➞

Show inline comments

 import datetime
 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):
         assert self.repo.get_config_value('universal', 'foo', TEST_USER_CONFIG_FILE) == 'bar'
     def test_get_config_value_defaults_to_None(self):
         assert self.repo.get_config_value('universal', 'nonexist', TEST_USER_CONFIG_FILE) == None
     def test_get_user_name(self):
         assert self.repo.get_user_name(TEST_USER_CONFIG_FILE) == 'Foo Bar'
     def test_get_user_email(self):
         assert self.repo.get_user_email(TEST_USER_CONFIG_FILE) == 'foo.bar@example.com'
     def test_repo_equality(self):
         assert self.repo == self.repo
     def test_repo_equality_broken_object(self):
         import copy
         _repo = copy.copy(self.repo)
         delattr(_repo, 'path')
         assert self.repo != _repo
     def test_repo_equality_other_object(self):
         class dummy(object):
             path = self.repo.path
         assert self.repo != dummy()
 class TestGitRepositoryBase(RepositoryBaseTest):
     backend_alias = 'git'
 class TestHgRepositoryBase(RepositoryBaseTest):
     backend_alias = 'hg'
 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': [
                     FileNode('foobar', content='foobar'),
                     FileNode('foobar2', content='foobar2'),
                 ],
             },
+            {
                 'message': 'Changed foobar, added foobar3',
                 'author': 'Jane Doe <jane.doe@example.com>',
                 'date': datetime.datetime(2010, 1, 1, 21),
                 'added': [
                     FileNode('foobar3', content='foobar3'),
                 ],
                 'changed': [
                     FileNode('foobar', 'FOOBAR'),
                 ],
             },
+            {
                 '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')],
             },
+            {
                 'message': u'Commit that contains glob pattern in filename',
                 'author': 'Jane Doe <jane.doe@example.com>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'added': [
                     FileNode('README{', content='Strangely-named README file'),
                 ],
             },
+        ]
         return commits
     def test_raise_for_wrong(self):
         with pytest.raises(ChangesetDoesNotExistError):
             self.repo.get_diff('a' * 40, 'b' * 40)
     def test_glob_patterns_in_filename_do_not_raise_exception(self):
         revs = self.repo.revisions
         diff = self.repo.get_diff(revs[2], revs[3], path='README{') # should not raise
 class TestGitRepositoryGetDiff(RepositoryGetDiffTest):
     backend_alias = 'git'
     def test_initial_commit_diff(self):
         initial_rev = self.repo.revisions[0]
         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
         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
@@ @@ -155,105 +162,96 @@ index 389865bb681b358c9b102d79abd8d5f941 @@
 \ 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
 '''
     def test_fourth_changeset_diff(self):
         revs = self.repo.revisions
         assert self.repo.get_diff(revs[2], revs[3]) == '''diff --git a/README{ b/README{
 new file mode 100644
 index 0000000000000000000000000000000000000000..cdc0c1b5d234feedb37bbac19cd1b6442061102d
 --- /dev/null
 +++ b/README{
@@ -0,0 +1 @@
 +Strangely-named README file
 \ No newline at end of file
 '''
 class TestHgRepositoryGetDiff(RepositoryGetDiffTest):
     backend_alias = 'hg'
     def test_initial_commit_diff(self):
         initial_rev = self.repo.revisions[0]
         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
         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
         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
 '''
     def test_fourth_changeset_diff(self):
         revs = self.repo.revisions
         assert self.repo.get_diff(revs[2], revs[3]) == '''diff --git a/README{ b/README{
 new file mode 100644
 --- /dev/null
 +++ b/README{
@@ -0,0 +1,1 @@
 +Strangely-named README file
 \ No newline at end of file
 '''
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
+    }
     cls_name = 'Test' + alias.capitalize() + RepositoryBaseTest.__name__
     globals()[cls_name] = type(cls_name, (RepositoryBaseTest,), attrs)

kallithea/tests/vcs/test_tags.py

➞

Show inline comments

 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)
         assert len(self.repo.tags) == tagsize + 1
         for top, dirs, files in tip.walk():
             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)
         with pytest.raises(TagAlreadyExistError):
             self.repo.tag('last-commit', 'joe', tip.raw_id)
         chset = self.repo.get_changeset(0)
         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')
         assert len(self.repo.tags) == tagsize - 1
     def test_remove_tag_which_does_not_exist(self):
         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')
         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(('test %s tags' % alias).title().split())
     globals()[cls_name] = type(cls_name, (TagsTestCaseMixin,), attrs)
 class TestGitTags(TagsTestCaseMixin):
     backend_alias = 'git'
 class TestHgTags(TagsTestCaseMixin):
     backend_alias = 'hg'

kallithea/tests/vcs/test_workdirs.py

➞

Show inline comments

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

0 comments (0 inline, 0 general)