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

# 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/>.

"""

Helpers for fixture generation

"""

import os

import time

from kallithea.tests import *

from kallithea.model.db import Repository, User, RepoGroup, UserGroup

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.user import UserModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.user_group import UserGroupModel

from kallithea.model.gist import GistModel

from kallithea.model.scm import ScmModel

from kallithea.lib.vcs.backends.base import EmptyChangeset

dn = os.path.dirname

FIXTURES = os.path.join(dn(dn(os.path.abspath(__file__))), 'tests', 'fixtures')

def error_function(*args, **kwargs):

    raise Exception('Total Crash !')

class Fixture(object):

    def __init__(self):

        pass

    def anon_access(self, status):

        """

        Context process for disabling anonymous access. use like:

        fixture = Fixture()

        with fixture.anon_access(False):

            #tests

        after this block anon access will be set to `not status`

        """

        class context(object):

            def __enter__(self):

                anon = User.get_default_user()

                anon.active = status

                Session().add(anon)

                Session().commit()

            def __exit__(self, exc_type, exc_val, exc_tb):

                anon = User.get_default_user()

                anon.active = not status

                Session().add(anon)

                Session().commit()

        return context()

    def _get_repo_create_params(self, **custom):

        defs = dict(

            repo_name=None,

            repo_type='hg',

            clone_uri='',

            repo_group='-1',

            repo_description='DESC',

            repo_private=False,

            repo_landing_rev='rev:tip',

            repo_copy_permissions=False,

            repo_state=Repository.STATE_CREATED,

        )

        defs.update(custom)

        if 'repo_name_full' not in custom:

            defs.update({'repo_name_full': defs['repo_name']})

        # fix the repo name if passed as repo_name_full

        if defs['repo_name']:

            defs['repo_name'] = defs['repo_name'].split('/')[-1]

        return defs

    def _get_group_create_params(self, **custom):

        defs = dict(

            group_name=None,

            group_description='DESC',

            group_parent_id=None,

            perms_updates=[],

            perms_new=[],

            enable_locking=False,

            recursive=False

        )

        defs.update(custom)

        return defs

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

        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, **kwargs):

        if 'skip_if_exists' in kwargs:

            del kwargs['skip_if_exists']

            r = Repository.get_by_repo_name(name)

            if r:

                return r

        if isinstance(kwargs.get('repo_group'), RepoGroup):

            kwargs['repo_group'] = kwargs['repo_group'].group_id

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

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

        RepoModel().create(form_data, cur_user)

        Session().commit()

        return Repository.get_by_repo_name(name)

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

        repo_to_fork = Repository.get_by_repo_name(repo_to_fork)

        form_data = self._get_repo_create_params(repo_name=fork_name,

                                            fork_parent_id=repo_to_fork,

                                            repo_type=repo_to_fork.repo_type,

                                            **kwargs)

        form_data['update_after_clone'] = False

issue_pat = (?:\s*#)(\d+)

## server url to the issue, each {id} will be replaced with match

## fetched from the regex and {repo} is replaced with full repository name

## including groups {repo_name} is replaced with just name of repo

issue_server_link = https://myissueserver.com/{repo}/issue/{id}

## prefix to add to link to indicate it's an url

## #314 will be replaced by <issue_prefix><id>

issue_prefix = #

## issue_pat, issue_server_link, issue_prefix can have suffixes to specify

## multiple patterns, to other issues server, wiki or others

## below an example how to create a wiki pattern

# wiki-some-id -> https://mywiki.com/some-id

#issue_pat_wiki = (?:wiki-)(.+)

#issue_server_link_wiki = https://mywiki.com/{id}

#issue_prefix_wiki = WIKI-

## instance-id prefix

## a prefix key for this instance used for cache invalidation when running

## multiple instances of kallithea, make sure it's globally unique for

## all running kallithea instances. Leave empty if you don't use it

instance_id =

## alternative return HTTP header for failed authentication. Default HTTP

## response is 401 HTTPUnauthorized. Currently Mercurial clients have trouble with

## handling that. Set this variable to 403 to return HTTPForbidden

auth_ret_code =

## locking return code. When repository is locked return this HTTP code. 2XX

## codes don't break the transactions while 4XX codes do

lock_ret_code = 423

## allows to change the repository location in settings page

allow_repo_location_change = True

## allows to setup custom hooks in settings page

allow_custom_hooks_settings = True

####################################

###        CELERY CONFIG        ####

####################################

use_celery = false

broker.host = localhost

broker.vhost = rabbitmqhost

broker.port = 5672

broker.user = rabbitmq

broker.password = qweqwe

celery.imports = kallithea.lib.celerylib.tasks

celery.result.backend = amqp

celery.result.dburi = amqp://

celery.result.serialier = json

#celery.send.task.error.emails = true

#celery.amqp.task.result.expires = 18000

celeryd.concurrency = 2

#celeryd.log.file = celeryd.log

celeryd.log.level = debug

celeryd.max.tasks.per.child = 1

## tasks will never be sent to the queue, but executed locally instead.

celery.always.eager = false

####################################

###         BEAKER CACHE        ####

####################################

beaker.cache.data_dir=%(here)s/data/cache/data

beaker.cache.lock_dir=%(here)s/data/cache/lock

beaker.cache.regions=super_short_term,short_term,long_term,sql_cache_short,sql_cache_med,sql_cache_long

beaker.cache.super_short_term.type=memory

beaker.cache.super_short_term.expire=10

beaker.cache.super_short_term.key_length = 256

beaker.cache.short_term.type=memory

beaker.cache.short_term.expire=60

beaker.cache.short_term.key_length = 256

beaker.cache.long_term.type=memory

beaker.cache.long_term.expire=36000

beaker.cache.long_term.key_length = 256

beaker.cache.sql_cache_short.type=memory

beaker.cache.sql_cache_short.key_length = 256

beaker.cache.sql_cache_med.type=memory

beaker.cache.sql_cache_med.expire=360

beaker.cache.sql_cache_med.key_length = 256

beaker.cache.sql_cache_long.type=file

beaker.cache.sql_cache_long.expire=3600

beaker.cache.sql_cache_long.key_length = 256

####################################

###       BEAKER SESSION        ####

####################################

## Type of storage used for the session, current types are

## dbm, file, memcached, database, and memory.

## The storage uses the Container API

## that is also used by the cache system.

## db session ##

#beaker.session.type = ext:database

#beaker.session.sa.url = postgresql://postgres:qwe@localhost/kallithea

#beaker.session.table_name = db_session

## encrypted cookie client side session, good for many instances ##

#beaker.session.type = cookie

## file based cookies (default) ##

#beaker.session.type = file

beaker.session.key = kallithea

beaker.session.secret = {74e0cd75-b339-478b-b129-07dd221def1f}

## Secure encrypted cookie. Requires AES and AES python libraries

## you must disable beaker.session.secret to use this

#beaker.session.encrypt_key = <key_for_encryption>

#beaker.session.validate_key = <validation_key>

## sets session as invalid if it haven't been accessed for given amount of time

beaker.session.timeout = 2592000

beaker.session.httponly = true

#beaker.session.cookie_path = /<your-prefix>

## uncomment for https secure cookie

beaker.session.secure = false

## auto save the session to not to use .save()

beaker.session.auto = False

## default cookie expiration time in seconds `true` expire at browser close ##

#beaker.session.cookie_expires = 3600

############################

## ERROR HANDLING SYSTEMS ##

############################

####################

### [errormator] ###

####################

## Errormator is tailored to work with Kallithea, see

## http://errormator.com for details how to obtain an account

## you must install python package `errormator_client` to make it work

## errormator enabled

errormator = false

errormator.server_url = https://api.errormator.com

errormator.api_key = YOUR_API_KEY

## TWEAK AMOUNT OF INFO SENT HERE

## enables 404 error logging (default False)

errormator.report_404 = false

## time in seconds after request is considered being slow (default 1)

errormator.slow_request_time = 1

## record slow requests in application

## (needs to be enabled for slow datastore recording and time tracking)

errormator.slow_requests = true

## enable hooking to application loggers

# errormator.logging = true

## minimum log level for log capture

# errormator.logging.level = WARNING

## send logs only from erroneous/slow requests

## (saves API quota for intensive logging)

errormator.logging_on_error = false

## list of additonal keywords that should be grabbed from environ object

## can be string with comma separated list of words in lowercase

## (by default client will always send following info:

## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that