defs = dict(

            username=name,

            password='qweqwe',

            email='%s+test@example.com' % name,

            firstname='TestUser',

            lastname='Test',

            active=True,

            admin=False,

            extern_type='internal',

            extern_name=None

        )

        defs.update(custom)

        return defs

    def _get_user_group_create_params(self, name, **custom):

        defs = dict(

            users_group_name=name,

            user_group_description='DESC',

            users_group_active=True,

            user_group_data={},

        )

        defs.update(custom)

        return defs

    def create_repo(self, name, repo_group=None, **kwargs):

        if 'skip_if_exists' in kwargs:

            del kwargs['skip_if_exists']

            r = db.Repository.get_by_repo_name(name)

            if r:

                return r

        if isinstance(repo_group, db.RepoGroup):

            repo_group = repo_group.group_id

        form_data = self._get_repo_create_params(repo_name=name, **kwargs)

        form_data['repo_group'] = repo_group # patch form dict so it can be used directly by model

        cur_user = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)

        RepoModel().create(form_data, cur_user)

        meta.Session().commit()

        ScmModel().mark_for_invalidation(name)

        return db.Repository.get_by_repo_name(name)

    def create_fork(self, repo_to_fork, fork_name, **kwargs):

        repo_to_fork = db.Repository.get_by_repo_name(repo_to_fork)

        form_data = self._get_repo_create_params(repo_name=fork_name,

                                            repo_type=repo_to_fork.repo_type,

                                            **kwargs)

        # patch form dict so it can be used directly by model

        form_data['description'] = form_data['repo_description']

        form_data['private'] = form_data['repo_private']

        form_data['landing_rev'] = form_data['repo_landing_rev']

        owner = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)

        RepoModel().create_fork(form_data, cur_user=owner)

        meta.Session().commit()

        ScmModel().mark_for_invalidation(fork_name)

        r = db.Repository.get_by_repo_name(fork_name)

        assert r

        return r

    def destroy_repo(self, repo_name, **kwargs):

        RepoModel().delete(repo_name, **kwargs)

        meta.Session().commit()

    def create_repo_group(self, name, parent_group_id=None, **kwargs):

        assert '/' not in name, (name, kwargs) # use group_parent_id to make nested groups

        if 'skip_if_exists' in kwargs:

            del kwargs['skip_if_exists']

            gr = db.RepoGroup.get_by_group_name(group_name=name)

            if gr:

                return gr

        form_data = self._get_repo_group_create_params(group_name=name, **kwargs)

        gr = RepoGroupModel().create(

            group_name=form_data['group_name'],

            group_description=form_data['group_name'],

            parent=parent_group_id,

            owner=kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN),

            )

        meta.Session().commit()

        gr = db.RepoGroup.get_by_group_name(gr.group_name)

        return gr

    def destroy_repo_group(self, repogroupid):

        RepoGroupModel().delete(repogroupid)

        meta.Session().commit()

    def create_user(self, name, **kwargs):

        if 'skip_if_exists' in kwargs:

            del kwargs['skip_if_exists']

            user = db.User.get_by_username(name)

            if user:

                return user

        form_data = self._get_user_create_params(name, **kwargs)