# copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb 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 Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

"""Test tools for cubicweb"""

__docformat__ = "restructuredtext en"

import os

import sys

import errno

import logging

import shutil

import pickle

import glob

import random

import subprocess

import warnings

import tempfile

import getpass

from hashlib import sha1 # pylint: disable=E0611

from datetime import timedelta

from os.path import (abspath, realpath, join, exists, split, isabs, isdir)

from functools import partial

from logilab.common.date import strptime

from logilab.common.decorators import cached, clear_cache

from cubicweb import ExecutionError, BadConnectionId

from cubicweb import schema, cwconfig

from cubicweb.server.serverconfig import ServerConfiguration

from cubicweb.etwist.twconfig import WebConfigurationBase

cwconfig.CubicWebConfiguration.cls_adjust_sys_path()

# db auto-population configuration #############################################

SYSTEM_ENTITIES = (schema.SCHEMA_TYPES

                   | schema.INTERNAL_TYPES

                   | schema.WORKFLOW_TYPES

                   | set(('CWGroup', 'CWUser',))

                   )

SYSTEM_RELATIONS = (schema.META_RTYPES

                    | schema.WORKFLOW_RTYPES

                    | schema.WORKFLOW_DEF_RTYPES

                    | schema.SYSTEM_RTYPES

                    | schema.SCHEMA_TYPES

                    | set(('primary_email', # deducted from other relations

                           ))

                    )

# content validation configuration #############################################

# validators are used to validate (XML, DTD, whatever) view's content

# validators availables are :

#  'dtd' : validates XML + declared DTD

#  'xml' : guarantees XML is well formed

#  None : do not try to validate anything

# {'vid': validator}

VIEW_VALIDATORS = {}

# cubicweb test configuration ##################################################

BASE_URL = 'http://testing.fr/cubicweb/'

DEFAULT_SOURCES = {'system': {'adapter' : 'native',

                              'db-encoding' : 'UTF-8', #'ISO-8859-1',

                              'db-user' : u'admin',

                              'db-password' : 'gingkow',

                              'db-name' : 'tmpdb',

                              'db-driver' : 'sqlite',

                              'db-host' : None,

                              },

                   'admin' : {'login': u'admin',

                              'password': u'gingkow',

                              },

                   }

DEFAULT_PSQL_SOURCES = DEFAULT_SOURCES.copy()

DEFAULT_PSQL_SOURCES['system'] = DEFAULT_SOURCES['system'].copy()

DEFAULT_PSQL_SOURCES['system']['db-driver'] = 'postgres'

DEFAULT_PSQL_SOURCES['system']['db-user'] = unicode(getpass.getuser())

DEFAULT_PSQL_SOURCES['system']['db-password'] = None

def turn_repo_off(repo):

    """ Idea: this is less costly than a full re-creation of the repo object.

    off:

    * session are closed,

    * cnxsets are closed

    * system source is shutdown

    """

    if not repo._needs_refresh:

        for sessionid in list(repo._sessions):

            warnings.warn('%s Open session found while turning repository off'

                          %sessionid, RuntimeWarning)

            try:

                repo.close(sessionid)

            except BadConnectionId: #this is strange ? thread issue ?

                print 'XXX unknown session', sessionid

        for cnxset in repo.cnxsets:

            cnxset.close(True)

        repo.system_source.shutdown()

        repo._needs_refresh = True

        repo._has_started = False

def turn_repo_on(repo):

    """Idea: this is less costly than a full re-creation of the repo object.

    on:

    * cnxsets are connected

    * cache are cleared

    """

    if repo._needs_refresh:

        for cnxset in repo.cnxsets:

            cnxset.reconnect()

        repo._type_source_cache = {}

        repo._extid_cache = {}

        repo.querier._rql_cache = {}

        repo.system_source.reset_caches()

        repo._needs_refresh = False

class TestServerConfiguration(ServerConfiguration):

    mode = 'test'

    read_instance_schema = False

    init_repository = True

    skip_db_create_and_restore = False

    default_sources = DEFAULT_SOURCES

    def __init__(self, appid='data', apphome=None, log_threshold=logging.CRITICAL+10):

        # must be set before calling parent __init__

        if apphome is None:

            if exists(appid):

                apphome = abspath(appid)

            else: # cube test

                apphome = abspath('..')

        self._apphome = apphome

        ServerConfiguration.__init__(self, appid)

        self.init_log(log_threshold, force=True)

        # need this, usually triggered by cubicweb-ctl

        self.load_cwctl_plugins()

    # By default anonymous login are allow but some test need to deny of to

    # change the default user. Set it to None to prevent anonymous login.

    anonymous_credential = ('anon', 'anon')

    def anonymous_user(self):

        if not self.anonymous_credential:

            return None, None

        return self.anonymous_credential

    def set_anonymous_allowed(self, allowed, anonuser='anon'):

        if allowed:

            self.anonymous_credential = (anonuser, anonuser)

        else:

            self.anonymous_credential = None

    @property

    def apphome(self):

        return self._apphome

    appdatahome = apphome

    def load_configuration(self):

        super(TestServerConfiguration, self).load_configuration()

        # no undo support in tests

        self.global_set_option('undo-enabled', 'n')

    def main_config_file(self):

        """return instance's control configuration file"""

        return join(self.apphome, '%s.conf' % self.name)

    def bootstrap_cubes(self):

        try:

            super(TestServerConfiguration, self).bootstrap_cubes()

        except IOError:

            # no cubes

            self.init_cubes( () )

    sourcefile = None

    def sources_file(self):

        """define in subclasses self.sourcefile if necessary"""

        if self.sourcefile:

            print 'Reading sources from', self.sourcefile

            sourcefile = self.sourcefile

            if not isabs(sourcefile):

                sourcefile = join(self.apphome, sourcefile)

        else:

            sourcefile = super(TestServerConfiguration, self).sources_file()

        return sourcefile

    def read_sources_file(self):

        """By default, we run tests with the sqlite DB backend.  One may use its

        own configuration by just creating a 'sources' file in the test

        directory from which tests are launched or by specifying an alternative

        sources file using self.sourcefile.

        """

        try:

            sources = super(TestServerConfiguration, self).read_sources_file()

        except ExecutionError:

            sources = {}

        if not sources:

            sources = self.default_sources

        if 'admin' not in sources:

            sources['admin'] = self.default_sources['admin']

        return sources

    # web config methods needed here for cases when we use this config as a web

    # config

    def default_base_url(self):

        return BASE_URL

class BaseApptestConfiguration(TestServerConfiguration, WebConfigurationBase):

    name = 'all-in-one' # so it search for all-in-one.conf, not repository.conf

    options = cwconfig.merge_options(TestServerConfiguration.options

                                     + WebConfigurationBase.options)

    cubicweb_appobject_path = TestServerConfiguration.cubicweb_appobject_path | WebConfigurationBase.cubicweb_appobject_path

    cube_appobject_path = TestServerConfiguration.cube_appobject_path | WebConfigurationBase.cube_appobject_path

    def available_languages(self, *args):

        return self.cw_languages()

# XXX merge with BaseApptestConfiguration ?

class ApptestConfiguration(BaseApptestConfiguration):

    # `skip_db_create_and_restore` controls wether or not the test database

    # should be created / backuped / restored. If set to True, those

    # steps are completely skipped, the database is used as is and is

    # considered initialized

    skip_db_create_and_restore = False

    def __init__(self, appid, apphome=None,

                 log_threshold=logging.WARNING, sourcefile=None):

        BaseApptestConfiguration.__init__(self, appid, apphome,

                                          log_threshold=log_threshold)

        self.init_repository = sourcefile is None

        self.sourcefile = sourcefile

class PostgresApptestConfiguration(ApptestConfiguration):

    default_sources = DEFAULT_PSQL_SOURCES

class RealDatabaseConfiguration(ApptestConfiguration):

    """configuration class for tests to run on a real database.

    The intialization is done by specifying a source file path.

    Important note: init_test_database / reset_test_database steps are

    skipped. It's thus up to the test developer to implement setUp/tearDown

    accordingly.

    Example usage::

      class MyTests(CubicWebTC):

          _config = RealDatabaseConfiguration('myapp',

                                              sourcefile='/path/to/sources')

          def test_something(self):

              with self.admin_access.web_request() as req:

                  rset = req.execute('Any X WHERE X is CWUser')

                  self.view('foaf', rset, req=req)

    """

    skip_db_create_and_restore = True

    read_instance_schema = True # read schema from database

# test database handling #######################################################

DEFAULT_EMPTY_DB_ID = '__default_empty_db__'

class TestDataBaseHandler(object):

    DRIVER = None

    db_cache = {}

    explored_glob = set()

    def __init__(self, config, init_config=None):

        self.config = config

        self.init_config = init_config

        self._repo = None

        # pure consistency check

        assert self.system_source['db-driver'] == self.DRIVER

    def _ensure_test_backup_db_dir(self):

        """Return path of directory for database backup.

        The function create it if necessary"""

        backupdir = join(self.config.apphome, 'database')

        try:

            os.makedirs(backupdir)

        except:

            if not isdir(backupdir):

                raise

        return backupdir

    def config_path(self, db_id):

        """Path for config backup of a given database id"""

        return self.absolute_backup_file(db_id, 'config')

    def absolute_backup_file(self, db_id, suffix):

        """Path for config backup of a given database id"""

        # in case db name is an absolute path, we don't want to replace anything

        # in parent directories

        directory, basename = split(self.dbname)

        dbname = basename.replace('-', '_')

        assert '.' not in db_id

        filename = join(directory, '%s-%s.%s' % (dbname, db_id, suffix))

        return join(self._ensure_test_backup_db_dir(), filename)

    def db_cache_key(self, db_id, dbname=None):

        """Build a database cache key for a db_id with the current config

        This key is meant to be used in the cls.db_cache mapping"""

        if dbname is None:

            dbname = self.dbname

        dbname = os.path.basename(dbname)

        dbname = dbname.replace('-', '_')

        return (self.config.apphome, dbname, db_id)

    def backup_database(self, db_id):

        """Store the content of the current database as <db_id>

        The config used are also stored."""

        backup_data = self._backup_database(db_id)

        config_path = self.config_path(db_id)

        # XXX we dump a dict of the config

        # This is an experimental to help config dependant setup (like BFSS) to

        # be propertly restored

        with tempfile.NamedTemporaryFile(dir=os.path.dirname(config_path), delete=False) as conf_file:

            conf_file.write(pickle.dumps(dict(self.config)))

        os.rename(conf_file.name, config_path)

        self.db_cache[self.db_cache_key(db_id)] = (backup_data, config_path)

    def _backup_database(self, db_id):

        """Actual backup the current database.

        return a value to be stored in db_cache to allow restoration"""

        raise NotImplementedError()

    def restore_database(self, db_id):

        """Restore a database.

        takes as argument value stored in db_cache by self._backup_database"""

        # XXX set a clearer error message ???

        backup_coordinates, config_path = self.db_cache[self.db_cache_key(db_id)]

        # reload the config used to create the database.

        config = pickle.loads(open(config_path, 'rb').read())

        # shutdown repo before changing database content

        if self._repo is not None:

            self._repo.turn_repo_off()

        self._restore_database(backup_coordinates, config)

    def _restore_database(self, backup_coordinates, config):

        """Actual restore of the current database.

        Use the value stored in db_cache as input """

        raise NotImplementedError()

    def get_repo(self, startup=False):

        """ return Repository object on the current database.

        (turn the current repo object "on" if there is one or recreate one)

        if startup is True, server startup server hooks will be called if needed

        """

        if self._repo is None:

            self._repo = self._new_repo(self.config)

        # config has now been bootstrapped, call init_config if specified

        if self.init_config is not None:

            self.init_config(self.config)

        repo = self._repo

        repo.turn_repo_on()

        if startup and not repo._has_started:

            repo.hm.call_hooks('server_startup', repo=repo)

            repo._has_started = True

        return repo

    def _new_repo(self, config):

        """Factory method to create a new Repository Instance"""

        from cubicweb.repoapi import _get_inmemory_repo

        config._cubes = None

        repo = _get_inmemory_repo(config)

        # extending Repository class

        repo._has_started = False