hggit.ui_value = ''

        hggit.ui_active = False

        self.sa.add(hggit)

    def create_auth_plugin_options(self, skip_existing=False):

        """

        Create default auth plugin settings, and make it active

        :param skip_existing:

        """

        for k, v, t in [('auth_plugins', 'kallithea.lib.auth_modules.auth_internal', 'list'),

                log.debug('Skipping option %s', k)

                continue

            setting = Setting(k, v, t)

            self.sa.add(setting)

    def create_default_options(self, skip_existing=False):

        """Creates default settings"""

        for k, v, t in [

            ('default_repo_enable_locking',  False, 'bool'),

            ('default_repo_enable_downloads', False, 'bool'),

            ('default_repo_enable_statistics', False, 'bool'),

                   version=other._version)

        s1, s2 = self.subnet()

        while s1 != other and s2 != other:

            if other in s1:

                ret_addrs.append(s2)

                s1, s2 = s1.subnet()

            elif other in s2:

                ret_addrs.append(s1)

                s1, s2 = s2.subnet()

            else:

                # If we got here, there's a bug somewhere.

        if s1 == other:

            ret_addrs.append(s2)

        elif s2 == other:

            ret_addrs.append(s1)

        else:

            # If we got here, there's a bug somewhere.

        return sorted(ret_addrs, key=_BaseNet._get_networks_key)

    def compare_networks(self, other):

        """Compare two IP objects.

        This is only concerned about the comparison of the integer

        representation of the network addresses.  This means that the

        host bits aren't considered at all in this method.  If you want

        to compare host bits, you can easily enough do a

        'HostA._ip < HostB._ip'

            'id': id_,

            'error': expected,

            'result': None

        })

        given = json.loads(given)

        assert expected == given

    def test_Optional_object(self):

        from kallithea.controllers.api.api import Optional

        option1 = Optional(None)

        assert '<Optional:%s>' % None == repr(option1)

        assert 1 == Optional.extract(Optional(1))

        assert 'trololo' == Optional.extract('trololo')

    def test_Optional_OAttr(self):

        from kallithea.controllers.api.api import Optional, OAttr

        option1 = Optional(OAttr('apiuser'))

        assert 'apiuser' == Optional.extract(option1)

    def test_OAttr_object(self):

        from kallithea.controllers.api.api import OAttr

            RepoModel().revoke_user_permission(self.REPO, self.TEST_USER_LOGIN)

    def test_api_create_repo(self):

        repo_name = u'api-repo'

        id_, params = _build_data(self.apikey, 'create_repo',

                                  repo_name=repo_name,

                                  owner=TEST_USER_ADMIN_LOGIN,

                                  repo_type=self.REPO_TYPE,

        )

        response = api_call(self, params)

        repo = RepoModel().get_by_repo_name(repo_name)

        ret = {

            'msg': 'Created new repository `%s`' % repo_name,

            'success': True,

            'task': None,

        }

        expected = ret

        self._compare_ok(id_, expected, given=response.body)

        fixture.destroy_repo(repo_name)

    def test_api_create_repo_and_repo_group(self):

        repo_name = u'my_gr/api-repo'

        id_, params = _build_data(self.apikey, 'create_repo',

                                  repo_name=repo_name,

                                  owner=TEST_USER_ADMIN_LOGIN,

                                  repo_type=self.REPO_TYPE,)

        response = api_call(self, params)

        print params

        repo = RepoModel().get_by_repo_name(repo_name)

        ret = {

            'msg': 'Created new repository `%s`' % repo_name,

            'success': True,

            'task': None,

        }

        expected = ret

        self._compare_ok(id_, expected, given=response.body)

        fixture.destroy_repo(repo_name)

        fixture.destroy_repo_group(u'my_gr')

    def test_api_create_repo_in_repo_group_without_permission(self):

        repo_group_name = u'%s/api-repo-repo' % TEST_REPO_GROUP

        self._compare_error(id_, expected, given=response.body)

    def test_api_create_repo_dont_specify_owner(self):

        repo_name = u'api-repo'

        owner = 'i-dont-exist'

        id_, params = _build_data(self.apikey, 'create_repo',

                                  repo_name=repo_name,

                                  repo_type=self.REPO_TYPE,

        )

        response = api_call(self, params)

        repo = RepoModel().get_by_repo_name(repo_name)

        ret = {

            'msg': 'Created new repository `%s`' % repo_name,

            'success': True,

            'task': None,

        }

        expected = ret

        self._compare_ok(id_, expected, given=response.body)

        fixture.destroy_repo(repo_name)

    def test_api_create_repo_by_non_admin(self):

        repo_name = u'api-repo'

        owner = 'i-dont-exist'

        id_, params = _build_data(self.apikey_regular, 'create_repo',

                                  repo_name=repo_name,

                                  repo_type=self.REPO_TYPE,

        )

        response = api_call(self, params)

        repo = RepoModel().get_by_repo_name(repo_name)

        ret = {

            'msg': 'Created new repository `%s`' % repo_name,

            'success': True,

            'task': None,

        }

        expected = ret

        self._compare_ok(id_, expected, given=response.body)

        fixture.destroy_repo(repo_name)

    def test_api_create_repo_by_non_admin_specify_owner(self):

        repo_name = u'api-repo'

        owner = 'i-dont-exist'

        response = self.app.post(url('delete_repo', repo_name=repo_name),

            params={'_authentication_token': self.authentication_token()})

        self.checkSessionFlash(response, 'Deleted repository %s' % (repo_name))

        response.follow()

        # check if repo was deleted from db

        deleted_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name).scalar()

        assert os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name)) == False

    def test_delete_non_ascii(self):

        self.log_user()

        non_ascii = "ąęł"

        repo_name = "%s%s" % (safe_str(self.NEW_REPO), non_ascii)

        repo_name_unicode = safe_unicode(repo_name)

        description = 'description for newly created repo' + non_ascii

        description_unicode = safe_unicode(description)

        response = self.app.post(url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

        except vcs.exceptions.VCSError:

            pytest.fail('no repo %s in filesystem' % repo_name)

        response = self.app.post(url('delete_repo', repo_name=repo_name),

            params={'_authentication_token': self.authentication_token()})

        self.checkSessionFlash(response, 'Deleted repository %s' % (repo_name_unicode))

        response.follow()

        # check if repo was deleted from db

        deleted_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name_unicode).scalar()

        assert os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name_unicode)) == False

    def test_delete_repo_with_group(self):

        # TODO:

        pass

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('delete_repo', repo_name=self.REPO),

                                 params=dict(_authentication_token=self.authentication_token()))

    def test_show(self):

        response = self.app.post(url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               'Error creating repository %s' % repo_name)

        # repo must not be in db

        repo = Repository.get_by_repo_name(repo_name)

        # repo must not be in filesystem !

        assert not os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name))

class TestAdminReposControllerGIT(_BaseTestCase):

    REPO = GIT_REPO

    REPO_TYPE = 'git'

    NEW_REPO = NEW_GIT_REPO

    OTHER_TYPE_REPO = HG_REPO

    OTHER_TYPE = 'hg'

        self.checkSessionFlash(response,

                               'Created user group ')

        gr = Session().query(UserGroup) \

            .filter(UserGroup.users_group_name == users_group_name).one()

        response = self.app.post(url('delete_users_group', id=gr.users_group_id),

            params={'_authentication_token': self.authentication_token()})

        gr = Session().query(UserGroup) \

            .filter(UserGroup.users_group_name == users_group_name).scalar()

    def test_default_perms_enable_repository_read_on_group(self):

        self.log_user()

        users_group_name = TEST_USER_GROUP + 'another2'

        response = self.app.post(url('users_groups'),

                                 {'users_group_name': users_group_name,

                                  'user_group_description': u'DESC',

                                  'active': True,

                                  '_authentication_token': self.authentication_token()})

        response.follow()

        ug = UserGroup.get_by_group_name(users_group_name)

                    [ug.users_group_id, p2.permission_id],

                    [ug.users_group_id, p3.permission_id]])

        # DELETE !

        ug = UserGroup.get_by_group_name(users_group_name)

        ugid = ug.users_group_id

        response = self.app.post(url('delete_users_group', id=ug.users_group_id),

            params={'_authentication_token': self.authentication_token()})

        response = response.follow()

        gr = Session().query(UserGroup) \

            .filter(UserGroup.users_group_name == users_group_name).scalar()

        p = Permission.get_by_key('hg.create.repository')

        perms = UserGroupToPerm.query() \

            .filter(UserGroupToPerm.users_group_id == ugid).all()

        perms = [[x.users_group_id,

                  x.permission_id, ] for x in perms]

        assert perms == []

    def test_default_perms_enable_repository_fork_on_group(self):

        self.log_user()

        users_group_name = TEST_USER_GROUP + 'another2'

        response = self.app.post(url('users_groups'),

                                 {'users_group_name': users_group_name,

                    [ug.users_group_id, p3.permission_id]])

        # DELETE !

        ug = UserGroup.get_by_group_name(users_group_name)

        ugid = ug.users_group_id

        response = self.app.post(url('delete_users_group', id=ug.users_group_id),

            params={'_authentication_token': self.authentication_token()})

        response = response.follow()

        gr = Session().query(UserGroup) \

                           .filter(UserGroup.users_group_name ==

                                   users_group_name).scalar()

        p = Permission.get_by_key('hg.fork.repository')

        perms = UserGroupToPerm.query() \

            .filter(UserGroupToPerm.users_group_id == ugid).all()

        perms = [[x.users_group_id,

                  x.permission_id, ] for x in perms]

        assert perms == []

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('delete_users_group', id=1),

                                 params=dict(_authentication_token=self.authentication_token()))

                                             'firstname': name,

                                             'lastname': lastname,

                                             'admin': True})  # This should be overridden

        assert response.status == '302 Found'

        self.checkSessionFlash(response, 'You have successfully registered with Kallithea')

        ret = Session().query(User).filter(User.username == 'test_regular4').one()

        assert ret.username == username

        assert check_password(password, ret.password) == True

        assert ret.email == email

        assert ret.name == name

        assert ret.lastname == lastname

        assert ret.admin == False

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

    # PASSWORD RESET

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

    def test_forgot_password_wrong_mail(self):

        bad_email = 'username%wrongmail.org'

        response = self.app.post(

                        url(controller='login', action='password_reset'),

                            {'email': bad_email, }

        )

                                  'org_repo': HG_REPO,

                                  'org_ref': 'rev:94f45ed825a1:94f45ed825a113e61af7e141f44ca578374abef0',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:96507bd11ecc815ebc6270fdf6db110928c09c1e',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  '_authentication_token': self.authentication_token(),

                                 },

                                status=302)

        # location is of the form:

        # http://localhost/vcs_test_hg/pull-request/54/_/title

        m = re.search('/pull-request/(\d+)/', response.location)

        pull_request_id = m.group(1)

        # update it

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

                                     repo_name=HG_REPO, pull_request_id=pull_request_id),

                                 {

                                  'updaterev': '4f7e2131323e0749a740c0a56ab68ae9269c562a',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  'owner': TEST_USER_ADMIN_LOGIN,

                                  '_authentication_token': self.authentication_token(),

                                  'review_members': [str(invalid_user_id)],

                                  'org_repo': HG_REPO,

                                  'org_ref': 'branch:stable:4f7e2131323e0749a740c0a56ab68ae9269c562a',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:96507bd11ecc815ebc6270fdf6db110928c09c1e',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  '_authentication_token': self.authentication_token(),

                                 },

                                status=302)

        # location is of the form:

        # http://localhost/vcs_test_hg/pull-request/54/_/title

        m = re.search('/pull-request/(\d+)/', response.location)

        pull_request_id = m.group(1)

        # edit it

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

                                     repo_name=HG_REPO, pull_request_id=pull_request_id),

                                 {

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  'owner': TEST_USER_ADMIN_LOGIN,

                                  '_authentication_token': self.authentication_token(),

                                  'review_members': [str(invalid_user_id)],

                                 },

        ('group.read', 'group.none'),

        ('usergroup.read', 'usergroup.none'),

        ('hg.create.repository', 'hg.create.none'),

        ('hg.fork.repository', 'hg.fork.none'),

        ('hg.register.manual_activate', 'hg.register.auto_activate',)

    ])

    def test_set_default_permissions_after_modification(self, perm, modify_to):

        PermissionModel().create_default_permissions(user=self.u1)

        self._test_def_perm_equal(user=self.u1)

        old = Permission.get_by_key(perm)

        new = Permission.get_by_key(modify_to)

        # now modify permissions

        p = UserToPerm.query() \

                .filter(UserToPerm.user == self.u1) \

                .filter(UserToPerm.permission == old) \

                .one()

        p.permission = new

        Session().commit()

        PermissionModel().create_default_permissions(user=self.u1)

        self._test_def_perm_equal(user=self.u1)

        assert sg1.full_path == 'test1/sub1'

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

        ssg1 = fixture.create_repo_group(u'subsub1', parent_group_id=sg1.group_id)

        assert ssg1.parent_group == sg1

        assert ssg1.full_path == 'test1/sub1/subsub1'

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

    def test_remove_group(self):

        sg1 = fixture.create_repo_group(u'deleteme')

        self.__delete_group(sg1.group_id)

        assert not self.__check_path('deteteme')

        sg1 = fixture.create_repo_group(u'deleteme', parent_group_id=self.g1.group_id)

        self.__delete_group(sg1.group_id)

        assert not self.__check_path('test1', 'deteteme')

    def test_rename_single_group(self):

        sg1 = fixture.create_repo_group(u'initial')

        new_sg1 = _update_repo_group(sg1.group_id, u'after')

        assert self.__check_path('after')

    def test_update_group_parent(self):

        sg1 = fixture.create_repo_group(u'initial', parent_group_id=self.g1.group_id)

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

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

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

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

        assert RepoGroup.get_by_group_name(u'test3/initial') == None

        new_sg1 = _update_repo_group(sg1.group_id, u'hello')

        assert self.__check_path('hello')

        assert RepoGroup.get_by_group_name(u'hello') == new_sg1

    def test_subgrouping_with_repo(self):

class TestRepos(TestController):

    def teardown_method(self, method):

        Session.remove()

    def test_remove_repo(self):

        repo = fixture.create_repo(name=u'test-repo-1')

        Session().commit()

        RepoModel().delete(repo=repo)

        Session().commit()

    def test_remove_repo_repo_raises_exc_when_attached_forks(self):

        repo = fixture.create_repo(name=u'test-repo-1')

        Session().commit()

        fixture.create_fork(repo.repo_name, u'test-repo-fork-1')

        Session().commit()

        with pytest.raises(AttachedForksError):

            RepoModel().delete(repo=repo)

        # cleanup

        RepoModel().delete(repo=u'test-repo-fork-1')

        Session().commit()

        fork = fixture.create_fork(repo.repo_name, u'test-repo-fork-1')

        Session().commit()

        # fork of fork

        fixture.create_fork(fork.repo_name, u'test-repo-fork-fork-1')

        Session().commit()

        RepoModel().delete(repo=repo, forks='delete')

        Session().commit()

    def test_remove_repo_detach_forks(self):

        repo = fixture.create_repo(name=u'test-repo-1')

        Session().commit()

        fork = fixture.create_fork(repo.repo_name, u'test-repo-fork-1')

        Session().commit()

        # fork of fork

        fixture.create_fork(fork.repo_name, u'test-repo-fork-fork-1')

        Session().commit()

        RepoModel().delete(repo=repo, forks='detach')

        Session().commit()

        try:

        finally:

            RepoModel().delete(repo=u'test-repo-fork-fork-1')

            RepoModel().delete(repo=u'test-repo-fork-1')

            Session().commit()

        u = User.get_by_email(email='MAIN_email@example.com')

        assert usr.user_id == u.user_id

        assert usr.username == u.username

        u = User.get_by_email(email='main_email@example.com')

        assert usr.user_id == u.user_id

        assert usr.username == u.username

        u = User.get_by_email(email='main_email2@example.com')

        assert usr.user_id == u.user_id

        assert usr.username == u.username

        u = User.get_by_email(email='main_email3@example.com')

        u = User.get_by_email(email='main_e%ail@example.com')

        u = User.get_by_email(email='main_emai_@example.com')

        UserModel().delete(usr.user_id)

        Session().commit()

class TestUsers(TestController):

    def setup_method(self, method):

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

                                        password=u'qweqwe',

                                        email=u'u1@example.com',

                                        firstname=u'u1', lastname=u'u1')

        validator = v.ValidRepoGroup(edit=True,

                                      old_data={'group_id':  gr.group_id})

        with pytest.raises(formencode.Invalid):

            validator.to_python({

                                        'group_name': gr.group_name + 'n',

                                        'parent_group_id': gr.group_id

                                        })

        model.delete(gr)

    def test_ValidPassword(self):

        validator = v.ValidPassword()

        assert 'lol' == validator.to_python('lol')

        with pytest.raises(formencode.Invalid):

            validator.to_python('ąćżź')

    def test_ValidPasswordsMatch(self):

        validator = v.ValidPasswordsMatch('new_password', 'password_confirmation')

        with pytest.raises(formencode.Invalid):

            validator.to_python({'new_password': 'pass',

                                          'password_confirmation': 'pass2'})

        with pytest.raises(formencode.Invalid):

            validator.to_python({'new_password': 'pass',

                                          'password_confirmation': 'pass2'})