action='store_true',

                           dest='public_access',

                           default=None,

                           help='Enable public access on this installation (default)')

        parser.add_argument('--no-public-access',

                           action='store_false',

                           dest='public_access',

                           default=None,

                           help='Disable public access on this installation ')

        return parser

    def take_action(self, opts):

        dbconf = self.config['sqlalchemy.url']

        dbmanage = DbManage(dbconf=dbconf, root=self.config['here'],

                            tests=False, cli_args=vars(opts))

        dbmanage.create_tables(override=True)

        opts = dbmanage.config_prompt(None)

        dbmanage.create_settings(opts)

        dbmanage.create_default_user()

        dbmanage.admin_prompt()

        dbmanage.create_permissions()

        dbmanage.populate_default_permissions()

        Session().commit()

        if None not in [start, end] and start_pos > end_pos:

            raise RepositoryError('start cannot be after end')

        if end_pos is not None:

            end_pos += 1

        revs = revs[start_pos:end_pos]

        if reverse:

            revs = reversed(revs)

        return CollectionGenerator(self, revs)

    def get_diff(self, rev1, rev2, path=None, ignore_whitespace=False,

                 context=3):

        """

        Returns (git like) *diff*, as plain text. Shows changes introduced by

        ``rev2`` since ``rev1``.

        :param rev1: Entry point from which diff is shown. Can be

          ``self.EMPTY_CHANGESET`` - in this case, patch showing all

          the changes since empty state of the repository until ``rev2``

        :param rev2: Until which revision changes should be shown.

        :param ignore_whitespace: If set to ``True``, would not show whitespace

          changes. Defaults to ``False``.

        :param context: How many lines before/after changed lines should be

        """

        flags = ['-U%s' % context, '--full-index', '--binary', '-p', '-M', '--abbrev=40']

        if ignore_whitespace:

            flags.append('-w')

        if hasattr(rev1, 'raw_id'):

            rev1 = getattr(rev1, 'raw_id')

        if hasattr(rev2, 'raw_id'):

            rev2 = getattr(rev2, 'raw_id')

        if rev1 == self.EMPTY_CHANGESET:

            rev2 = self.get_changeset(rev2).raw_id

            cmd = ['show'] + flags + [rev2]

        else:

            rev1 = self.get_changeset(rev1).raw_id

            rev2 = self.get_changeset(rev2).raw_id

            cmd = ['diff'] + flags + [rev1, rev2]

        if path:

            cmd += ['--', path]

        stdout, stderr = self.run_git_command(cmd)

        # TODO: don't ignore stderr

        # If we used 'show' command, strip first few lines (until actual diff

            return {}

        sortkey = lambda ctx: ctx[0]  # sort by name

        _bookmarks = [(safe_unicode(n), hex(h),) for n, h in

                 self._repo._bookmarks.items()]

        return OrderedDict(sorted(_bookmarks, key=sortkey, reverse=True))

    def _get_all_revisions(self):

        return [self._repo[x].hex() for x in self._repo.filtered('visible').changelog.revs()]

    def get_diff(self, rev1, rev2, path='', ignore_whitespace=False,

                  context=3):

        """

        Returns (git like) *diff*, as plain text. Shows changes introduced by

        ``rev2`` since ``rev1``.

        :param rev1: Entry point from which diff is shown. Can be

          ``self.EMPTY_CHANGESET`` - in this case, patch showing all

          the changes since empty state of the repository until ``rev2``

        :param rev2: Until which revision changes should be shown.

        :param ignore_whitespace: If set to ``True``, would not show whitespace

          changes. Defaults to ``False``.

        :param context: How many lines before/after changed lines should be

        """

        if hasattr(rev1, 'raw_id'):

            rev1 = getattr(rev1, 'raw_id')

        if hasattr(rev2, 'raw_id'):

            rev2 = getattr(rev2, 'raw_id')

        # Check if given revisions are present at repository (may raise

        # ChangesetDoesNotExistError)

        if rev1 != self.EMPTY_CHANGESET:

            self.get_changeset(rev1)

        self.get_changeset(rev2)

        if path:

            file_filter = match(self.path, '', [path])

        else:

            file_filter = None

        return ''.join(patch.diff(self._repo, rev1, rev2, match=file_filter,

                          opts=diffopts(git=True,

                                        showfunc=True,

                                        ignorews=ignore_whitespace,

                                        context=context)))

    @classmethod

    def _check_url(cls, url, repoui=None):

{

    "name": "Kallithea",

    "icons": [

        {

            "src": "/images/android-chrome-192x192.png",

            "sizes": "192x192",

            "type": "image/png"

        },

        {

            "src": "/images/android-chrome-512x512.png",

            "sizes": "512x512",

            "type": "image/png"

        }

    ],

    "theme_color": "#ffffff",

    "background_color": "#ffffff",

    "display": "standalone"

          ('non-absolute-path',),

    ])

    def test_login_bad_came_froms(self, url_came_from):

        response = self.app.post(url(controller='login', action='index',

                                     came_from=url_came_from),

                                 {'username': TEST_USER_ADMIN_LOGIN,

                                  'password': TEST_USER_ADMIN_PASS},

                                 status=400)

    def test_login_short_password(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username': TEST_USER_ADMIN_LOGIN,

                                  'password': 'as'})

        assert response.status == '200 OK'

        response.mustcontain('Enter 3 characters or more')

    def test_login_wrong_username_password(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username': 'error',

                                  'password': 'test12'})

        response.mustcontain('Invalid username or password')

    # verify that get arguments are correctly passed along login redirection

    @parametrize('args,args_encoded', [

        ({'foo':'one', 'bar':'two'}, (('foo', 'one'), ('bar', 'two'))),

        ({'blue': u'blå'.encode('utf-8'), 'green':u'grøn'},

             (('blue', u'blå'.encode('utf-8')), ('green', u'grøn'.encode('utf-8')))),

    ])

    def test_redirection_to_login_form_preserves_get_args(self, args, args_encoded):

        with fixture.anon_access(False):

            response = self.app.get(url(controller='summary', action='index',

                                        repo_name=HG_REPO,

                                        **args))

            assert response.status == '302 Found'

            came_from = urlparse.parse_qs(urlparse.urlparse(response.location).query)['came_from'][0]

            came_from_qs = urlparse.parse_qsl(urlparse.urlparse(came_from).query)

            for encoded in args_encoded:

                assert encoded in came_from_qs

    @parametrize('args,args_encoded', [

        ({'foo':'one', 'bar':'two'}, ('foo=one', 'bar=two')),

        ({'blue': u'blå', 'green':u'grøn'},

             ('blue=bl%C3%A5', 'green=gr%C3%B8n')),

    ])

    def test_login_form_preserves_get_args(self, args, args_encoded):

        self.repo.run_git_command(['checkout', 'master'])

        assert self.repo.workdir.get_branch() == 'master'

    def test_get_diff_runs_git_command_with_hashes(self):

        self.repo.run_git_command = mock.Mock(return_value=['', ''])

        self.repo.get_diff(0, 1)

        self.repo.run_git_command.assert_called_once_with(

            ['diff', '-U3', '--full-index', '--binary', '-p', '-M', '--abbrev=40',

             self.repo._get_revision(0), self.repo._get_revision(1)])

    def test_get_diff_runs_git_command_with_str_hashes(self):

        self.repo.run_git_command = mock.Mock(return_value=['', ''])

        self.repo.get_diff(self.repo.EMPTY_CHANGESET, 1)

        self.repo.run_git_command.assert_called_once_with(

            ['show', '-U3', '--full-index', '--binary', '-p', '-M', '--abbrev=40',

             self.repo._get_revision(1)])

    def test_get_diff_runs_git_command_with_path_if_its_given(self):

        self.repo.run_git_command = mock.Mock(return_value=['', ''])

        self.repo.get_diff(0, 1, 'foo')

        self.repo.run_git_command.assert_called_once_with(

            ['diff', '-U3', '--full-index', '--binary', '-p', '-M', '--abbrev=40',

             self.repo._get_revision(0), self.repo._get_revision(1), '--', 'foo'])

class TestGitRegression(_BackendTestMixin):

    backend_alias = 'git'

    @classmethod

    def _get_commits(cls):

        return [

            {

                'message': 'Initial',

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 20),

                'added': [

                    FileNode('bot/__init__.py', content='base'),

                    FileNode('bot/templates/404.html', content='base'),

                    FileNode('bot/templates/500.html', content='base'),

                ],

            },

            {

                'message': 'Second',

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 22),

                'added': [

                    FileNode('bot/build/migrations/1.py', content='foo2'),

                    FileNode('bot/build/migrations/2.py', content='foo2'),

import os

import pytest

from kallithea.lib.utils2 import safe_str

from kallithea.lib.vcs.backends.hg import MercurialRepository, MercurialChangeset

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError, NodeDoesNotExistError

from kallithea.lib.vcs.nodes import NodeKind, NodeState

from kallithea.tests.vcs.conf import TEST_HG_REPO, TEST_HG_REPO_CLONE, \

    TEST_HG_REPO_PULL, TESTS_TMP_PATH

class TestMercurialRepository(object):

    def __check_for_existing_repo(self):

        if os.path.exists(TEST_HG_REPO_CLONE):

            pytest.fail('Cannot test mercurial clone repo as location %s already '

                      'exists. You should manually remove it first.'

                      % TEST_HG_REPO_CLONE)

    def setup_method(self):

        self.repo = MercurialRepository(safe_str(TEST_HG_REPO))

    def test_wrong_repo_path(self):

        wrong_repo_path = os.path.join(TESTS_TMP_PATH, 'errorrepo')

        with pytest.raises(RepositoryError):

        # Small chance we ever get to this one

        revision = pow(2, 30)

        with pytest.raises(RepositoryError):

            self.repo.get_changeset(revision)

    def test_changeset10(self):

        chset10 = self.repo.get_changeset(10)

        readme = """===

VCS

===

Various Version Control System management abstraction layer for Python.

Introduction

------------

TODO: To be written...

"""

        node = chset10.get_node('README.rst')

        assert node.kind == NodeKind.FILE

        assert node.content == readme

class TestMercurialChangeset(object):

    def setup_method(self):

        self.repo = MercurialRepository(safe_str(TEST_HG_REPO))

    def _test_equality(self, changeset):

        revision = changeset.revision

        assert changeset == self.repo.get_changeset(revision)

    def test_equality(self):

        revs = [0, 10, 20]

        changesets = [self.repo.get_changeset(rev) for rev in revs]

        for changeset in changesets:

            self._test_equality(changeset)

    def test_default_changeset(self):

        tip = self.repo.get_changeset('tip')

        assert tip == self.repo.get_changeset()

        assert tip == self.repo.get_changeset(revision=None)

        assert tip == list(self.repo[-1:])[0]

    def test_root_node(self):

        tip = self.repo.get_changeset('tip')