dest='email',

                          default=None,

                          help='Admin Email')

        parser.add_argument('--password',

                          action='store',

                          dest='password',

                          default=None,

                          help='Admin password min 6 chars')

        parser.add_argument('--repos',

                          action='store',

                          dest='repos_location',

                          default=None,

                          help='Absolute path to repositories location')

        parser.add_argument('--force-yes',

                           action='store_true',

                           dest='force_ask',

                           default=None,

                           help='Force yes to every question')

        parser.add_argument('--force-no',

                           action='store_false',

                           dest='force_ask',

                           default=None,

                           help='Force no to every question')

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

                           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 end_date:

            cmd += ['--until', end_date.strftime('%m/%d/%y %H:%M:%S')]

        if branch_name:

            cmd.append(branch_name)

        else:

            cmd.append(settings.GIT_REV_FILTER)

        revs = self.run_git_command(cmd)[0].splitlines()

        start_pos = 0

        end_pos = len(revs)

        if start:

            _start = self._get_revision(start)

            try:

                start_pos = revs.index(_start)

            except ValueError:

                pass

        if end is not None:

            _end = self._get_revision(end)

            try:

                end_pos = revs.index(_end)

            except ValueError:

                pass

        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

        # starts)

        if rev1 == self.EMPTY_CHANGESET:

            parts = stdout.split('\ndiff ', 1)

            if len(parts) > 1:

                stdout = 'diff ' + parts[1]

        return stdout

    @LazyProperty

    def in_memory_changeset(self):

        """

        Returns ``GitInMemoryChangeset`` object for this repository.

        """

        return GitInMemoryChangeset(self)

    def clone(self, url, update_after_clone=True, bare=False):

        """

        Tries to clone changes from external location.

        :param update_after_clone: If set to ``False``, git won't checkout

          working directory

        :param bare: If set to ``True``, repository would be cloned into

          *bare* git repository (no working directory at all).

        """

        url = self._get_url(url)

        """

        if name not in self.tags:

            raise TagDoesNotExistError("Tag %s does not exist" % name)

        if message is None:

            message = "Removed tag %s" % name

        if date is None:

            date = datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S')

        local = False

        try:

            tag(self._repo, name, nullid, message, local, user, date)

            self.tags = self._get_tags()

        except Abort as e:

            raise RepositoryError(e.message)

    @LazyProperty

    def bookmarks(self):

        """

        Gets bookmarks for this repository

        """

        return self._get_bookmarks()

    def _get_bookmarks(self):

        if self._empty:

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

        """

        Function will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError, exception is also thrown

        when the return code is non 200

        """

        # check first if it's not an local url

        if os.path.isdir(url) or url.startswith('file:'):

            return True

        if url.startswith('ssh:'):

            # in case of invalid uri or authentication issues, sshpeer will

            # throw an exception.

            sshpeer(repoui or ui.ui(), url).lookup('tip')

            return True

        url_prefix = None

        if '+' in url[:url.find('://')]:

            url_prefix, url = url.split('+', 1)

        handlers = []

{

    "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"

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

                                 {'username': TEST_USER_REGULAR_LOGIN,

                                  'password': TEST_USER_REGULAR_PASS})

        # Verify that a login session has been established.

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

        response = response.follow()

        assert 'authuser' in response.session

        response.click('Log Out')

        # Verify that the login session has been terminated.

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

        assert 'authuser' not in response.session

    @parametrize('url_came_from', [

          ('data:text/html,<script>window.alert("xss")</script>',),

          ('mailto:test@example.com',),

          ('file:///etc/passwd',),

          ('ftp://ftp.example.com',),

          ('http://other.example.com/bl%C3%A5b%C3%A6rgr%C3%B8d',),

          ('//evil.example.com/',),

          ('/\r\nX-Header-Injection: boo',),

          ('/invälid_url_bytes',),

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

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

                                    came_from=url('/_admin/users', **args)))

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

        for encoded in args_encoded:

            assert encoded in came_from

    @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_redirection_after_successful_login_preserves_get_args(self, args, args_encoded):

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

                                     came_from=url('/_admin/users', **args)),

                                 {'username': TEST_USER_ADMIN_LOGIN,

                                  'password': TEST_USER_ADMIN_PASS})

        assert response.status == '302 Found'

        for encoded in args_encoded:

            assert encoded in response.location

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

            {

                'message': 'Second',

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

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

                'added': [

                    FileNode('foo2', content='foo2'),

                ],

            },

        ]

    def test_paths_slow_traversing(self):

        cs = self.repo.get_changeset()

        assert cs.get_node('foobar').get_node('static').get_node('js').get_node('admin').get_node('base.js').content == 'base'

    def test_paths_fast_traversing(self):

        cs = self.repo.get_changeset()

        assert cs.get_node('foobar/static/js/admin/base.js').content == 'base'

    def test_workdir_get_branch(self):

        self.repo.run_git_command(['checkout', '-b', 'production'])

        # Regression test: one of following would fail if we don't check

        # .git/HEAD file

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

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

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

                    FileNode('bot/build/static/templates/f.html', content='foo2'),

                    FileNode('bot/build/static/templates/f1.html', content='foo2'),

                    FileNode('bot/build/templates/err.html', content='foo2'),

                    FileNode('bot/build/templates/err2.html', content='foo2'),

                ],

            },

        ]

    def test_similar_paths(self):

        cs = self.repo.get_changeset()

        paths = lambda *n: [x.path for x in n]

        assert paths(*cs.get_nodes('bot')) == ['bot/build', 'bot/templates', 'bot/__init__.py']

        assert paths(*cs.get_nodes('bot/build')) == ['bot/build/migrations', 'bot/build/static', 'bot/build/templates']

        assert paths(*cs.get_nodes('bot/build/static')) == ['bot/build/static/templates']

        # this get_nodes below causes troubles !

        assert paths(*cs.get_nodes('bot/build/static/templates')) == ['bot/build/static/templates/f.html', 'bot/build/static/templates/f1.html']

        assert paths(*cs.get_nodes('bot/build/templates')) == ['bot/build/templates/err.html', 'bot/build/templates/err2.html']

        assert paths(*cs.get_nodes('bot/templates/')) == ['bot/templates/404.html', 'bot/templates/500.html']

class TestGitHooks(object):

    """

    Tests related to hook functionality of Git repositories.

    """

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

            MercurialRepository(wrong_repo_path)

    def test_unicode_path_repo(self):

        with pytest.raises(VCSError):

            MercurialRepository(u'iShouldFail')

    def test_repo_clone(self):

        self.__check_for_existing_repo()

        repo = MercurialRepository(safe_str(TEST_HG_REPO))

        repo_clone = MercurialRepository(TEST_HG_REPO_CLONE,

            src_url=TEST_HG_REPO, update_after_clone=True)

        assert len(repo.revisions) == len(repo_clone.revisions)

        # Checking hashes of changesets should be enough

        for changeset in repo.get_changesets():

            raw_id = changeset.raw_id

            assert raw_id == repo_clone.get_changeset(raw_id).raw_id

    def test_repo_clone_with_update(self):

        repo = MercurialRepository(safe_str(TEST_HG_REPO))

        repo_clone = MercurialRepository(TEST_HG_REPO_CLONE + '_w_update',

            src_url=TEST_HG_REPO, update_after_clone=True)

        assert len(repo.revisions) == len(repo_clone.revisions)

        # check if current workdir was updated

        node = init_chset.get_node('vcs/')

        assert hasattr(node, 'kind')

        assert node.kind == NodeKind.DIR

        node = init_chset.get_node('vcs')

        assert hasattr(node, 'kind')

        assert node.kind == NodeKind.DIR

        node = init_chset.get_node('vcs/__init__.py')

        assert hasattr(node, 'kind')

        assert node.kind == NodeKind.FILE

    def test_not_existing_changeset(self):

        # rawid

        with pytest.raises(RepositoryError):

            self.repo.get_changeset('abcd' * 10)

        # shortid

        with pytest.raises(RepositoryError):

            self.repo.get_changeset('erro' * 4)

        # numeric

        with pytest.raises(RepositoryError):

            self.repo.get_changeset(self.repo.count() + 1)

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

        assert tip.root is tip.get_node('')

    def test_lazy_fetch(self):

        """

        Test if changeset's nodes expands and are cached as we walk through

        the revision. This test is somewhat hard to write as order of tests

        is a key here. Written by running command after command in a shell.

        """

        chset = self.repo.get_changeset(45)

        assert len(chset.nodes) == 0

        root = chset.root

        assert len(chset.nodes) == 1

        assert len(root.nodes) == 8

        # accessing root.nodes updates chset.nodes

        assert len(chset.nodes) == 9

        docs = root.get_node('docs')

        # we haven't yet accessed anything new as docs dir was already cached

        assert len(chset.nodes) == 9

        assert len(docs.nodes) == 8

        # accessing docs.nodes updates chset.nodes

        assert len(chset.nodes) == 17

        assert docs is chset.get_node('docs')