.. _changelog:

Changelog

=========

1.3.2 (**2012-XX-XX**)

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

:status: in-progress

:branch: beta

news

++++

fixes

+++++

- fixed git protocol issues with repos-groups

- fixed git remote repos validator that prevented from cloning remote git repos

- fixes #370 ending slashes fixes for repo and groups

- fixes #368 improved git-protocol detection to handle other clients

1.3.1 (**2012-02-27**)

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

news

++++

fixes

+++++

- redirection loop occurs when remember-me wasn't checked during login

- fixes issues with git blob history generation 

- don't fetch branch for git in file history dropdown. Causes unneeded slowness

1.3.0 (**2012-02-26**)

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

news

++++

- code review, inspired by github code-comments 

- #215 rst and markdown README files support

- #252 Container-based and proxy pass-through authentication support

                    # this updates also current one if found

                    ReposGroupModel().grant_user_permission(

                        repos_group=repos_group, user=member, perm=perm

                    )

                else:

                    ReposGroupModel().grant_users_group_permission(

                        repos_group=repos_group, group_name=member, perm=perm

                    )

            # set new permissions

            for member, perm, member_type in form_data['perms_new']:

                if member_type == 'user':

                    ReposGroupModel().grant_user_permission(

                        repos_group=repos_group, user=member, perm=perm

                    )

                else:

                    ReposGroupModel().grant_users_group_permission(

                        repos_group=repos_group, group_name=member, perm=perm

                    )

            old_path = repos_group.full_path

            # change properties

            repos_group.group_description = form_data['group_description']

            repos_group.parent_group = RepoGroup.get(form_data['group_parent_id'])

            repos_group.group_name = repos_group.get_new_name(form_data['group_name'])

            new_path = repos_group.full_path

            self.sa.add(repos_group)

            # we need to get all repositories from this new group and

            # rename them accordingly to new group path

            for r in repos_group.repositories:

                r.repo_name = r.get_new_name(r.just_name)

                self.sa.add(r)

            return repos_group

        except:

            log.error(traceback.format_exc())

            raise

    def delete(self, users_group_id):

        try:

            users_group = RepoGroup.get(users_group_id)

            self.sa.delete(users_group)

            self.__delete_group(users_group)

        except:

            log.error(traceback.format_exc())

            raise

    def grant_user_permission(self, repos_group, user, perm):

        """

        Grant permission for user on given repositories group, or update

        existing one if found

        :param repos_group: Instance of ReposGroup, repositories_group_id,

            or repositories_group name

        :param user: Instance of User, user_id or username

        :param perm: Instance of Permission, or permission_name

        """

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, \

    UsersGroup, UsersGroupMember, Permission

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)

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

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

    def tearDown(self):

        print 'out'

    def __check_path(self, *path):

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

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

                         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

        self.assertEqual(r.repo_name, os.path.join('g2', 'g1', r.just_name))

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