# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.files

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Files controller for RhodeCode

    :created_on: Apr 21, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# 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 os

import logging

import traceback

from pylons import request, response, tmpl_context as c, url

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from pylons.decorators import jsonify

from rhodecode.lib import diffs

from rhodecode.lib import helpers as h

from rhodecode.lib.compat import OrderedDict

from rhodecode.lib.utils2 import convert_line_endings, detect_mode, safe_str

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import EmptyChangeset

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import RepositoryError, \

    ChangesetDoesNotExistError, EmptyRepositoryError, \

    ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode.model.repo import RepoModel

from rhodecode.model.scm import ScmModel

from rhodecode.controllers.changeset import anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    @LoginRequired()

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

    def __get_cs_or_redirect(self, rev, repo_name, redirect_after=True):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :param repo_name: repo name to redirect after

        """

        try:

            return c.rhodecode_repo.get_changeset(rev)

        except EmptyRepositoryError, e:

            if not redirect_after:

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='')

            add_new = '<a href="%s">[%s]</a>' % (url_, _('add new'))

            h.flash(h.literal(_('There are no files yet %s' % add_new)),

                    category='warning')

            redirect(h.url('summary_home', repo_name=repo_name))

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name, revision='tip'))

    def __get_filenode_or_redirect(self, repo_name, cs, path):

        """

        Returns file_node, if error occurs or given path is directory,

        it'll redirect to top level path

        :param repo_name: repo_name

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=cs.raw_id))

        return file_node

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self, repo_name, revision, f_path, annotate=False):

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

            cs = self.__get_cs_or_redirect(post_revision, repo_name)

            redirect(url('files_home', repo_name=c.repo_name,

                         revision=cs.raw_id, f_path=f_path))

        c.changeset = self.__get_cs_or_redirect(revision, repo_name)

        c.branch = request.GET.get('branch', None)

        c.f_path = f_path

        c.annotate = annotate

        cur_rev = c.changeset.revision

        # prev link

        try:

            prev_rev = c.rhodecode_repo.get_changeset(cur_rev).prev(c.branch)

            c.url_prev = url('files_home', repo_name=c.repo_name,

                         revision=prev_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_prev += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_prev = '#'

        # next link

        try:

            next_rev = c.rhodecode_repo.get_changeset(cur_rev).next(c.branch)

            c.url_next = url('files_home', repo_name=c.repo_name,

                     revision=next_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_next += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_next = '#'

        # files or dirs

        try:

            c.file = c.changeset.get_node(f_path)

            if c.file.is_file():

                c.file_history = self._get_node_history(c.changeset, f_path)

            else:

                c.file_history = []

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=revision))

        return render('files/files.html')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def rawfile(self, repo_name, revision, f_path):

        cs = self.__get_cs_or_redirect(revision, repo_name)

        file_node = self.__get_filenode_or_redirect(repo_name, cs, f_path)

        response.content_disposition = 'attachment; filename=%s' % \

        response.content_type = file_node.mimetype

        return file_node.content

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def raw(self, repo_name, revision, f_path):

        cs = self.__get_cs_or_redirect(revision, repo_name)

        file_node = self.__get_filenode_or_redirect(repo_name, cs, f_path)

        raw_mimetype_mapping = {

            # map original mimetype to a mimetype used for "show as raw"

            # you can also provide a content-disposition to override the

            # default "attachment" disposition.

            # orig_type: (new_type, new_dispo)

            # show images inline:

            'image/x-icon': ('image/x-icon', 'inline'),

            'image/png': ('image/png', 'inline'),

            'image/gif': ('image/gif', 'inline'),

            'image/jpeg': ('image/jpeg', 'inline'),

            'image/svg+xml': ('image/svg+xml', 'inline'),

        }

        mimetype = file_node.mimetype

        try:

            mimetype, dispo = raw_mimetype_mapping[mimetype]

        except KeyError:

            # we don't know anything special about this, handle it safely

            if file_node.is_binary:

                # do same as download raw for binary files

                mimetype, dispo = 'application/octet-stream', 'attachment'

            else:

                # do not just use the original mimetype, but force text/plain,

                # otherwise it would serve text/html and that might be unsafe.

                # Note: underlying vcs library fakes text/plain mimetype if the

                # mimetype can not be determined and it thinks it is not

                # binary.This might lead to erroneous text display in some

                # cases, but helps in other cases, like with text files

                # without extension.

                mimetype, dispo = 'text/plain', 'inline'

        if dispo == 'attachment':

            dispo = 'attachment; filename=%s' % \

                        safe_str(f_path.split(os.sep)[-1])

        response.content_disposition = dispo

        response.content_type = mimetype

        return file_node.content

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def edit(self, repo_name, revision, f_path):

        r_post = request.POST

        c.cs = self.__get_cs_or_redirect(revision, repo_name)

        c.file = self.__get_filenode_or_redirect(repo_name, c.cs, f_path)

        if c.file.is_binary:

            return redirect(url('files_home', repo_name=c.repo_name,

                         revision=c.cs.raw_id, f_path=f_path))

        c.f_path = f_path

        if r_post:

            old_content = c.file.content

            sl = old_content.splitlines(1)

            first_line = sl[0] if sl else ''

            # modes:  0 - Unix, 1 - Mac, 2 - DOS

            mode = detect_mode(first_line, 0)

            content = convert_line_endings(r_post.get('content'), mode)

            message = r_post.get('message') or (_('Edited %s via RhodeCode')

                                                % (f_path))

            author = self.rhodecode_user.full_contact

            if content == old_content:

                h.flash(_('No changes'),

                    category='warning')

                return redirect(url('changeset_home', repo_name=c.repo_name,

                                    revision='tip'))

            try:

                self.scm_model.commit_change(repo=c.rhodecode_repo,

                                             repo_name=repo_name, cs=c.cs,

                                             user=self.rhodecode_user,

                                             author=author, message=message,

                                             content=content, f_path=f_path)

                h.flash(_('Successfully committed to %s' % f_path),

                        category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during commit'), category='error')

            return redirect(url('changeset_home',

                                repo_name=c.repo_name, revision='tip'))

<option value="86ede6754f2b27309452bb11f997386ae01d0e5a">r47:86ede6754f2b (web)</option>

<option value="014c40c0203c423dc19ecf94644f7cac9d4cdce0">r45:014c40c0203c (web)</option>

<option value="ee87846a61c12153b51543bf860e1026c6d3dcba">r30:ee87846a61c1 (default)</option>

<option value="9bb326a04ae5d98d437dece54be04f830cf1edd9">r26:9bb326a04ae5 (default)</option>

<option value="536c1a19428381cfea92ac44985304f6a8049569">r24:536c1a194283 (default)</option>

<option value="dc5d2c0661b61928834a785d3e64a3f80d3aad9c">r8:dc5d2c0661b6 (default)</option>

<option value="3803844fdbd3b711175fc3da9bdacfcd6d29a6fb">r7:3803844fdbd3 (default)</option>

</optgroup>

<optgroup label="Branches">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">default</option>

<option value="97e8b885c04894463c51898e14387d80c30ed1ee">git</option>

<option value="2e6a2bf9356ca56df08807f4ad86d480da72a8f4">web</option>

</optgroup>

<optgroup label="Tags">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">tip</option>

<option value="fd4bdb5e9b2a29b4393a4ac6caef48c17ee1a200">0.1.4</option>

<option value="17544fbfcd33ffb439e2b728b5d526b1ef30bfcf">0.1.3</option>

<option value="a7e60bff65d57ac3a1a1ce3b12a70f8a9e8a7720">0.1.2</option>

<option value="eb3a60fc964309c1a318b8dfe26aa2d1586c85ae">0.1.1</option>

</optgroup>

""")

        response.mustcontain("""<div class="commit">merge</div>""")

        response.mustcontain("""<span style="text-transform: uppercase;"><a href="#">branch: default</a></span>""")

    def test_file_annotation(self):

        self.log_user()

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

                                    repo_name=HG_REPO,

                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

                                    f_path='vcs/nodes.py',

                                    annotate=True))

        response.mustcontain("""<optgroup label="Changesets">

<option value="8911406ad776fdd3d0b9932a2e89677e57405a48">r167:8911406ad776 (default)</option>

<option value="aa957ed78c35a1541f508d2ec90e501b0a9e3167">r165:aa957ed78c35 (default)</option>

<option value="48e11b73e94c0db33e736eaeea692f990cb0b5f1">r140:48e11b73e94c (default)</option>

<option value="adf3cbf483298563b968a6c673cd5bde5f7d5eea">r126:adf3cbf48329 (default)</option>

<option value="6249fd0fb2cfb1411e764129f598e2cf0de79a6f">r113:6249fd0fb2cf (git)</option>

<option value="75feb4c33e81186c87eac740cee2447330288412">r109:75feb4c33e81 (default)</option>

<option value="9a4dc232ecdc763ef2e98ae2238cfcbba4f6ad8d">r108:9a4dc232ecdc (default)</option>

<option value="595cce4efa21fda2f2e4eeb4fe5f2a6befe6fa2d">r107:595cce4efa21 (default)</option>

<option value="4a8bd421fbc2dfbfb70d85a3fe064075ab2c49da">r104:4a8bd421fbc2 (default)</option>

<option value="57be63fc8f85e65a0106a53187f7316f8c487ffa">r102:57be63fc8f85 (default)</option>

<option value="5530bd87f7e2e124a64d07cb2654c997682128be">r101:5530bd87f7e2 (git)</option>

<option value="e516008b1c93f142263dc4b7961787cbad654ce1">r99:e516008b1c93 (default)</option>

<option value="41f43fc74b8b285984554532eb105ac3be5c434f">r93:41f43fc74b8b (default)</option>

<option value="cc66b61b8455b264a7a8a2d8ddc80fcfc58c221e">r92:cc66b61b8455 (default)</option>

<option value="73ab5b616b3271b0518682fb4988ce421de8099f">r91:73ab5b616b32 (default)</option>

<option value="e0da75f308c0f18f98e9ce6257626009fdda2b39">r82:e0da75f308c0 (default)</option>

<option value="fb2e41e0f0810be4d7103bc2a4c7be16ee3ec611">r81:fb2e41e0f081 (default)</option>

<option value="602ae2f5e7ade70b3b66a58cdd9e3e613dc8a028">r76:602ae2f5e7ad (default)</option>

<option value="a066b25d5df7016b45a41b7e2a78c33b57adc235">r73:a066b25d5df7 (default)</option>

<option value="637a933c905958ce5151f154147c25c1c7b68832">r61:637a933c9059 (web)</option>

<option value="0c21004effeb8ce2d2d5b4a8baf6afa8394b6fbc">r60:0c21004effeb (web)</option>

<option value="a1f39c56d3f1d52d5fb5920370a2a2716cd9a444">r59:a1f39c56d3f1 (web)</option>

<option value="97d32df05c715a3bbf936bf3cc4e32fb77fe1a7f">r58:97d32df05c71 (web)</option>

<option value="08eaf14517718dccea4b67755a93368341aca919">r57:08eaf1451771 (web)</option>

<option value="22f71ad265265a53238359c883aa976e725aa07d">r56:22f71ad26526 (web)</option>

<option value="97501f02b7b4330924b647755663a2d90a5e638d">r49:97501f02b7b4 (web)</option>

<option value="86ede6754f2b27309452bb11f997386ae01d0e5a">r47:86ede6754f2b (web)</option>

<option value="014c40c0203c423dc19ecf94644f7cac9d4cdce0">r45:014c40c0203c (web)</option>

<option value="ee87846a61c12153b51543bf860e1026c6d3dcba">r30:ee87846a61c1 (default)</option>

<option value="9bb326a04ae5d98d437dece54be04f830cf1edd9">r26:9bb326a04ae5 (default)</option>

<option value="536c1a19428381cfea92ac44985304f6a8049569">r24:536c1a194283 (default)</option>

<option value="dc5d2c0661b61928834a785d3e64a3f80d3aad9c">r8:dc5d2c0661b6 (default)</option>

<option value="3803844fdbd3b711175fc3da9bdacfcd6d29a6fb">r7:3803844fdbd3 (default)</option>

</optgroup>

<optgroup label="Branches">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">default</option>

<option value="97e8b885c04894463c51898e14387d80c30ed1ee">git</option>

<option value="2e6a2bf9356ca56df08807f4ad86d480da72a8f4">web</option>

</optgroup>

<optgroup label="Tags">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">tip</option>

<option value="fd4bdb5e9b2a29b4393a4ac6caef48c17ee1a200">0.1.4</option>

<option value="17544fbfcd33ffb439e2b728b5d526b1ef30bfcf">0.1.3</option>

<option value="a7e60bff65d57ac3a1a1ce3b12a70f8a9e8a7720">0.1.2</option>

<option value="eb3a60fc964309c1a318b8dfe26aa2d1586c85ae">0.1.1</option>

</optgroup>""")

        response.mustcontain("""<span style="text-transform: uppercase;"><a href="#">branch: default</a></span>""")

    def test_archival(self):

        self.log_user()

        for arch_ext, info in ARCHIVE_SPECS.items():

            fname = '27cd5cce30c96924232dffcd24178a07ffeb5dfc%s' % arch_ext

            filename = '%s-%s' % (HG_REPO, fname)

            response = self.app.get(url(controller='files', action='archivefile',

                                        repo_name=HG_REPO,

                                        fname=fname))

    def test_archival_wrong_ext(self):

        self.log_user()

        for arch_ext in ['tar', 'rar', 'x', '..ax', '.zipz']:

            fname = '27cd5cce30c96924232dffcd24178a07ffeb5dfc%s' % arch_ext

            response = self.app.get(url(controller='files', action='archivefile',

                                        repo_name=HG_REPO,

                                        fname=fname))

    def test_archival_wrong_revision(self):

        self.log_user()

        for rev in ['00x000000', 'tar', 'wrong', '@##$@$424213232', '232dffcd']:

            fname = '%s.zip' % rev

            response = self.app.get(url(controller='files', action='archivefile',

                                        repo_name=HG_REPO,

                                        fname=fname))

    #==========================================================================

    # RAW FILE

    #==========================================================================

    def test_raw_file_ok(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='rawfile',

                                    repo_name=HG_REPO,

                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

                                    f_path='vcs/nodes.py'))

    def test_raw_file_wrong_cs(self):

        self.log_user()

        rev = u'ERRORce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/nodes.py'

        response = self.app.get(url(controller='files', action='rawfile',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        msg = """Revision %r does not exist for this repository""" % (rev)

        self.checkSessionFlash(response, msg)

        msg = """%s""" % (HG_REPO)

        self.checkSessionFlash(response, msg)

    def test_raw_file_wrong_f_path(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/ERRORnodes.py'

        response = self.app.get(url(controller='files', action='rawfile',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        msg = "There is no file nor directory at the given path: %r at revision %r" % (f_path, rev[:12])

        self.checkSessionFlash(response, msg)

    #==========================================================================

    # RAW RESPONSE - PLAIN

    #==========================================================================

    def test_raw_ok(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='raw',

                                    repo_name=HG_REPO,

                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

                                    f_path='vcs/nodes.py'))

    def test_raw_wrong_cs(self):

        self.log_user()

        rev = u'ERRORcce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/nodes.py'

        response = self.app.get(url(controller='files', action='raw',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        msg = """Revision %r does not exist for this repository""" % (rev)

        self.checkSessionFlash(response, msg)

        msg = """%s""" % (HG_REPO)

        self.checkSessionFlash(response, msg)

    def test_raw_wrong_f_path(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/ERRORnodes.py'

        response = self.app.get(url(controller='files', action='raw',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        msg = "There is no file nor directory at the given path: %r at revision %r" % (f_path, rev[:12])

        self.checkSessionFlash(response, msg)

    def test_ajaxed_files_list(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        response = self.app.get(

            url('files_nodelist_home', repo_name=HG_REPO,f_path='/',revision=rev),

            extra_environ={'HTTP_X_PARTIAL_XHR': '1'},

        )

        response.mustcontain("vcs/web/simplevcs/views/repository.py")

import os

import unittest

from rhodecode.tests import *

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import RepoGroup, User, Notification, UserNotification, \

from sqlalchemy.exc import IntegrityError

from rhodecode.model.user import UserModel

from rhodecode.model.meta import Session

from rhodecode.model.notification import NotificationModel

from rhodecode.model.users_group import UsersGroupModel

from rhodecode.lib.auth import AuthUser

def _make_group(path, desc='desc', parent_id=None,

                 skip_if_exists=False):

    gr = RepoGroup.get_by_group_name(path)

    if gr and skip_if_exists:

        return gr

    gr = ReposGroupModel().create(path, desc, parent_id)

    return gr

class TestReposGroups(unittest.TestCase):

    def setUp(self):

        self.g1 = _make_group('test1', skip_if_exists=True)

        Session.commit()

        self.g2 = _make_group('test2', skip_if_exists=True)

        Session.commit()

        self.g3 = _make_group('test3', skip_if_exists=True)

        Session.commit()

    def tearDown(self):

        print 'out'

    def __check_path(self, *path):

        """

        Checks the path for existance !

        """

        path = [TESTS_TMP_PATH] + list(path)

        path = os.path.join(*path)

        return os.path.isdir(path)

    def _check_folders(self):

        print os.listdir(TESTS_TMP_PATH)

    def __delete_group(self, id_):

        ReposGroupModel().delete(id_)

    def __update_group(self, id_, path, desc='desc', parent_id=None):

        form_data = dict(

            group_name=path,

            group_description=desc,

            group_parent_id=parent_id,

            perms_updates=[],

            perms_new=[]

        )

        gr = ReposGroupModel().update(id_, form_data)

        return gr

    def test_create_group(self):

        g = _make_group('newGroup')

        self.assertEqual(g.full_path, 'newGroup')

        self.assertTrue(self.__check_path('newGroup'))

    def test_create_same_name_group(self):

        self.assertRaises(IntegrityError, lambda:_make_group('newGroup'))

        Session.rollback()

    def test_same_subgroup(self):

        sg1 = _make_group('sub1', parent_id=self.g1.group_id)

        self.assertEqual(sg1.parent_group, self.g1)

        self.assertEqual(sg1.full_path, 'test1/sub1')

        self.assertTrue(self.__check_path('test1', 'sub1'))

        ssg1 = _make_group('subsub1', parent_id=sg1.group_id)

        self.assertEqual(ssg1.parent_group, sg1)

        self.assertEqual(ssg1.full_path, 'test1/sub1/subsub1')

        self.assertTrue(self.__check_path('test1', 'sub1', 'subsub1'))

    def test_remove_group(self):

        sg1 = _make_group('deleteme')

        self.__delete_group(sg1.group_id)

        self.assertEqual(RepoGroup.get(sg1.group_id), None)

        self.assertFalse(self.__check_path('deteteme'))

        sg1 = _make_group('deleteme', parent_id=self.g1.group_id)

        self.__delete_group(sg1.group_id)

        self.assertEqual(RepoGroup.get(sg1.group_id), None)

        self.assertFalse(self.__check_path('test1', 'deteteme'))

    def test_rename_single_group(self):

        sg1 = _make_group('initial')

        new_sg1 = self.__update_group(sg1.group_id, 'after')

        self.assertTrue(self.__check_path('after'))

        self.assertEqual(RepoGroup.get_by_group_name('initial'), None)

    def test_update_group_parent(self):

        sg1 = _make_group('initial', parent_id=self.g1.group_id)

        new_sg1 = self.__update_group(sg1.group_id, 'after', parent_id=self.g1.group_id)

        self.assertTrue(self.__check_path('test1', 'after'))

        self.assertEqual(RepoGroup.get_by_group_name('test1/initial'), None)

        new_sg1 = self.__update_group(sg1.group_id, 'after', parent_id=self.g3.group_id)

        self.assertTrue(self.__check_path('test3', 'after'))

        self.assertEqual(RepoGroup.get_by_group_name('test3/initial'), None)

        new_sg1 = self.__update_group(sg1.group_id, 'hello')

        self.assertTrue(self.__check_path('hello'))

        self.assertEqual(RepoGroup.get_by_group_name('hello'), new_sg1)

    def test_subgrouping_with_repo(self):

        g1 = _make_group('g1')

        g2 = _make_group('g2')

        # create new repo

        form_data = dict(repo_name='john',

                         repo_name_full='john',

                         fork_name=None,

                         description=None,

                         repo_group=None,

                         private=False,

                         repo_type='hg',

                         clone_uri=None)

        cur_user = User.get_by_username(TEST_USER_ADMIN_LOGIN)

        r = RepoModel().create(form_data, cur_user)

        self.assertEqual(r.repo_name, 'john')

        # put repo into group

        form_data = form_data

        form_data['repo_group'] = g1.group_id

        form_data['perms_new'] = []

        form_data['perms_updates'] = []

        RepoModel().update(r.repo_name, form_data)

        self.assertEqual(r.repo_name, 'g1/john')

        self.__update_group(g1.group_id, 'g1', parent_id=g2.group_id)

        self.assertTrue(self.__check_path('g2', 'g1'))

        # test repo

    def test_move_to_root(self):

        g1 = _make_group('t11')

        Session.commit()

        Session.commit()

        self.assertTrue(self.__check_path('t11', 't22'))

        g2 = self.__update_group(g2.group_id, 'g22', parent_id=None)

        Session.commit()

        # we moved out group from t1 to '' so it's full path should be 'g2'

        self.assertFalse(self.__check_path('t11', 't22'))

        self.assertTrue(self.__check_path('g22'))

class TestUser(unittest.TestCase):

    def __init__(self, methodName='runTest'):

        Session.remove()

        super(TestUser, self).__init__(methodName=methodName)

    def test_create_and_remove(self):

        usr = UserModel().create_or_update(username=u'test_user', password=u'qweqwe',

                                     email=u'u232@rhodecode.org',

                                     name=u'u1', lastname=u'u1')

        Session.commit()

        self.assertEqual(User.get_by_username(u'test_user'), usr)

        # make users group

        users_group = UsersGroupModel().create('some_example_group')

        Session.commit()

        UsersGroupModel().add_user_to_group(users_group, usr)

        Session.commit()

        self.assertEqual(UsersGroup.get(users_group.users_group_id), users_group)

        self.assertEqual(UsersGroupMember.query().count(), 1)

        UserModel().delete(usr.user_id)

        Session.commit()

        self.assertEqual(UsersGroupMember.query().all(), [])

class TestNotifications(unittest.TestCase):

    def __init__(self, methodName='runTest'):

        Session.remove()

        self.u1 = UserModel().create_or_update(username=u'u1',

                                        password=u'qweqwe',

                                        email=u'u1@rhodecode.org',

                                        name=u'u1', lastname=u'u1')

        Session.commit()

        self.u1 = self.u1.user_id

        self.u2 = UserModel().create_or_update(username=u'u2',

                                        password=u'qweqwe',

                                        email=u'u2@rhodecode.org',

                                        name=u'u2', lastname=u'u3')

        Session.commit()

        self.u2 = self.u2.user_id

        self.u3 = UserModel().create_or_update(username=u'u3',

                                        password=u'qweqwe',

                                        email=u'u3@rhodecode.org',

                                        name=u'u3', lastname=u'u3')

        Session.commit()

        self.u3 = self.u3.user_id

        super(TestNotifications, self).__init__(methodName=methodName)

    def _clean_notifications(self):

        for n in Notification.query().all():

            Session.delete(n)

        Session.commit()

        self.assertEqual(Notification.query().all(), [])

    def tearDown(self):

        self._clean_notifications()

    def test_create_notification(self):

        self.assertEqual([], Notification.query().all())

        self.assertEqual([], UserNotification.query().all())

        usrs = [self.u1, self.u2]

        notification = NotificationModel().create(created_by=self.u1,

                                           subject=u'subj', body=u'hi there',

                                           recipients=usrs)

        Session.commit()

        u1 = User.get(self.u1)

        u2 = User.get(self.u2)

        u3 = User.get(self.u3)

        notifications = Notification.query().all()

        self.assertEqual(len(notifications), 1)

        unotification = UserNotification.query()\

            .filter(UserNotification.notification == notification).all()

        self.assertEqual(notifications[0].recipients, [u1, u2])

        self.assertEqual(notification.notification_id,

                         notifications[0].notification_id)

        self.assertEqual(len(unotification), len(usrs))

        self.assertEqual([x.user.user_id for x in unotification], usrs)

    def test_user_notifications(self):

        self.assertEqual([], Notification.query().all())

        self.assertEqual([], UserNotification.query().all())

        # add user to group

        UsersGroupModel().add_user_to_group(self.ug1, self.u1)

        # set permission to lower

        new_perm = 'repository.none'

        RepoModel().grant_user_permission(repo=HG_REPO, user=self.u1, perm=new_perm)

        Session.commit()

        u1_auth = AuthUser(user_id=self.u1.user_id)

        self.assertEqual(u1_auth.permissions['repositories'][HG_REPO],

                         new_perm)

        # grant perm for group this should override permission from user

        new_perm = 'repository.write'

        RepoModel().grant_users_group_permission(repo=HG_REPO,

                                                 group_name=self.ug1,

                                                 perm=new_perm)

        # check perms

        u1_auth = AuthUser(user_id=self.u1.user_id)

        perms = {

            'repositories_groups': {},

            'global': set([u'hg.create.repository', u'repository.read',

                           u'hg.register.manual_activate']),

            'repositories': {u'vcs_test_hg': u'repository.read'}

        }

        self.assertEqual(u1_auth.permissions['repositories'][HG_REPO],

                         new_perm)

        self.assertEqual(u1_auth.permissions['repositories_groups'],

                         perms['repositories_groups'])

    def test_propagated_permission_from_users_group_lower_weight(self):

        # make group

        self.ug1 = UsersGroupModel().create('G1')

        # add user to group

        UsersGroupModel().add_user_to_group(self.ug1, self.u1)

        # set permission to lower

        new_perm_h = 'repository.write'

        RepoModel().grant_user_permission(repo=HG_REPO, user=self.u1,

                                          perm=new_perm_h)

        Session.commit()

        u1_auth = AuthUser(user_id=self.u1.user_id)

        self.assertEqual(u1_auth.permissions['repositories'][HG_REPO],

                         new_perm_h)

        # grant perm for group this should NOT override permission from user

        # since it's lower than granted

        new_perm_l = 'repository.read'

        RepoModel().grant_users_group_permission(repo=HG_REPO,

                                                 group_name=self.ug1,

                                                 perm=new_perm_l)

        # check perms

        u1_auth = AuthUser(user_id=self.u1.user_id)

        perms = {

            'repositories_groups': {},

            'global': set([u'hg.create.repository', u'repository.read',

                           u'hg.register.manual_activate']),

            'repositories': {u'vcs_test_hg': u'repository.write'}

        }

        self.assertEqual(u1_auth.permissions['repositories'][HG_REPO],

                         new_perm_h)

        self.assertEqual(u1_auth.permissions['repositories_groups'],

                         perms['repositories_groups'])

    def test_repo_in_group_permissions(self):

        self.g1 = _make_group('group1', skip_if_exists=True)

        self.g2 = _make_group('group2', skip_if_exists=True)

        Session.commit()

        # both perms should be read !

        u1_auth = AuthUser(user_id=self.u1.user_id)

        self.assertEqual(u1_auth.permissions['repositories_groups'],

                         {u'group1': u'group.read', u'group2': u'group.read'})

        a1_auth = AuthUser(user_id=self.anon.user_id)

        self.assertEqual(a1_auth.permissions['repositories_groups'],

                 {u'group1': u'group.read', u'group2': u'group.read'})

        #Change perms to none for both groups

        ReposGroupModel().grant_user_permission(repos_group=self.g1,

                                                user=self.anon,

                                                perm='group.none')

        ReposGroupModel().grant_user_permission(repos_group=self.g2,

                                                user=self.anon,

                                                perm='group.none')

        u1_auth = AuthUser(user_id=self.u1.user_id)

        self.assertEqual(u1_auth.permissions['repositories_groups'],

                 {u'group1': u'group.none', u'group2': u'group.none'})

        a1_auth = AuthUser(user_id=self.anon.user_id)

        self.assertEqual(a1_auth.permissions['repositories_groups'],

                 {u'group1': u'group.none', u'group2': u'group.none'})

        # add repo to group

        form_data = {

            'repo_name':HG_REPO,