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

"""this module contains base classes and utilities for cubicweb tests"""

__docformat__ = "restructuredtext en"

import sys

import re

import urlparse

from os.path import dirname, join, abspath

from urllib import unquote

from math import log

from contextlib import contextmanager

from warnings import warn

from types import NoneType

from itertools import chain

import yams.schema

from logilab.common.testlib import TestCase, InnerTest, Tags

from logilab.common.pytest import nocoverage, pause_tracing, resume_tracing

from logilab.common.debugger import Debugger

from logilab.common.umessage import message_from_string

from logilab.common.decorators import cached, classproperty, clear_cache, iclassmethod

from logilab.common.deprecation import deprecated, class_deprecated

from logilab.common.shellutils import getlogin

from cubicweb import ValidationError, NoSelectableObject, AuthenticationError

from cubicweb import cwconfig, dbapi, devtools, web, server, repoapi

from cubicweb.utils import json

from cubicweb.sobjects import notification

from cubicweb.web import Redirect, application

from cubicweb.server.hook import SendMailOp

from cubicweb.server.session import Session

from cubicweb.devtools import SYSTEM_ENTITIES, SYSTEM_RELATIONS, VIEW_VALIDATORS

from cubicweb.devtools import fake, htmlparser, DEFAULT_EMPTY_DB_ID

from cubicweb.utils import json

# low-level utilities ##########################################################

class CubicWebDebugger(Debugger):

    """special debugger class providing a 'view' function which saves some

    html into a temporary file and open a web browser to examinate it.

    """

    def do_view(self, arg):

        import webbrowser

        data = self._getval(arg)

        with file('/tmp/toto.html', 'w') as toto:

            toto.write(data)

        webbrowser.open('file:///tmp/toto.html')

def line_context_filter(line_no, center, before=3, after=None):

    """return true if line are in context

    if after is None: after = before

    """

    if after is None:

        after = before

    return center - before <= line_no <= center + after

def unprotected_entities(schema, strict=False):

    """returned a set of each non final entity type, excluding "system" entities

    (eg CWGroup, CWUser...)

    """

    if strict:

        protected_entities = yams.schema.BASE_TYPES

    else:

        protected_entities = yams.schema.BASE_TYPES.union(SYSTEM_ENTITIES)

    return set(schema.entities()) - protected_entities

class JsonValidator(object):

    def parse_string(self, data):

        return json.loads(data)

@contextmanager

def real_error_handling(app):

    """By default, CubicWebTC `app` attribute (ie the publisher) is monkey

    patched so that unexpected error are raised rather than going through the

    `error_handler` method.

    By using this context manager you disable this monkey-patching temporarily.

    Hence when publishihng a request no error will be raised, you'll get

    req.status_out set to an HTTP error status code and the generated page will

    usually hold a traceback as HTML.

    >>> with real_error_handling(app):

    >>>     page = app.handle_request(req)

    """

    # remove the monkey patched error handler

    fake_error_handler = app.error_handler

    del app.error_handler

    # return the app

    yield app

    # restore

    app.error_handler = fake_error_handler

# email handling, to test emails sent by an application ########################

MAILBOX = []

class Email(object):

    """you'll get instances of Email into MAILBOX during tests that trigger

    some notification.

    * `msg` is the original message object

    * `recipients` is a list of email address which are the recipients of this

      message

    """

    def __init__(self, fromaddr, recipients, msg):

        self.fromaddr = fromaddr

        self.recipients = recipients

        self.msg = msg

    @property

    def message(self):

        return message_from_string(self.msg)

    @property

    def subject(self):

        return self.message.get('Subject')

    @property

    def content(self):

        return self.message.get_payload(decode=True)

    def __repr__(self):

        return '<Email to %s with subject %s>' % (','.join(self.recipients),

                                                  self.message.get('Subject'))

# the trick to get email into MAILBOX instead of actually sent: monkey patch

# cwconfig.SMTP object

class MockSMTP:

    def __init__(self, server, port):

        pass

    def close(self):

        pass

    def sendmail(self, fromaddr, recipients, msg):

        MAILBOX.append(Email(fromaddr, recipients, msg))

cwconfig.SMTP = MockSMTP

class TestCaseConnectionProxy(object):

    """thin wrapper around `cubicweb.dbapi.Connection` context-manager

    used in CubicWebTC (cf. `cubicweb.devtools.testlib.CubicWebTC.login` method)

    It just proxies to the default connection context manager but

    restores the original connection on exit.

    """

    def __init__(self, testcase, cnx):

        self.testcase = testcase

        self.cnx = cnx

    def __getattr__(self, attrname):

        return getattr(self.cnx, attrname)

    def __enter__(self):

        # already open

        return self.cnx

    def __exit__(self, exctype, exc, tb):

        try:

            return self.cnx.__exit__(exctype, exc, tb)

        finally:

            self.testcase.restore_connection()

# Repoaccess utility ###############################################3###########

class RepoAccess(object):

    """An helper to easily create object to access the repo as a specific user

    Each RepoAccess have it own session.

    A repo access can create three type of object:

    .. automethod:: cubicweb.testlib.RepoAccess.repo_cnx

    .. automethod:: cubicweb.testlib.RepoAccess.client_cnx

    .. automethod:: cubicweb.testlib.RepoAccess.web_request

    The RepoAccess need to be closed to destroy the associated Session.

    TestCase usually take care of this aspect for the user.

    .. automethod:: cubicweb.testlib.RepoAccess.close

    """

    def __init__(self, repo, login, requestcls):

        self._repo = repo

        self._login = login

        self.requestcls = requestcls

        # opening session

        #

        # XXX this very hackish code should be cleaned and move on repo.

        with repo.internal_cnx() as cnx:

            rset = cnx.execute('CWUser U WHERE U login %(u)s', {'u': login})

            user = rset.get_entity(0, 0)

            user.groups

            user.properties

            self._session = Session(user, repo)

            repo._sessions[self._session.sessionid] = self._session

            self._session.user._cw = self._session

    @ contextmanager

    def repo_cnx(self):

        """Context manager returning a server side connection for the user"""

        with self._session.new_cnx() as cnx:

            yield cnx

    @ contextmanager

    def client_cnx(self):

        """Context manager returning a client side connection for the user"""

        with repoapi.ClientConnection(self._session) as cnx:

            yield cnx

    @ contextmanager

    def web_request(self, url=None, headers={}, **kwargs):

        """Context manager returning a web request pre-linked to a client cnx

        To commit and rollback use::

            req.cnx.commit()

            req.cnx.rolback()

        """

        req = self.requestcls(self._repo.vreg, url=url, headers=headers, form=kwargs)

        clt_cnx = repoapi.ClientConnection(self._session)

        req.set_cnx(clt_cnx)

        with clt_cnx:

            yield req

    def close(self):

        """Close the session associated to the RepoAccess"""

        if self._session is not None:

            self._repo.close(self._session.sessionid)

        self._session = None

# base class for cubicweb tests requiring a full cw environments ###############

class CubicWebTC(TestCase):

    """abstract class for test using an apptest environment

    attributes:

    * `vreg`, the vregistry

    * `schema`, self.vreg.schema

    * `config`, cubicweb configuration

    * `cnx`, dbapi connection to the repository using an admin user

    * `session`, server side session associated to `cnx`

    * `app`, the cubicweb publisher (for web testing)

    * `repo`, the repository object

    * `admlogin`, login of the admin user

    * `admpassword`, password of the admin user

    * `shell`, create and use shell environment

    """

    appid = 'data'

    configcls = devtools.ApptestConfiguration

    tags = TestCase.tags | Tags('cubicweb', 'cw_repo')

    test_db_id = DEFAULT_EMPTY_DB_ID

    _cnxs = set() # establised connection

                  # stay on connection for leak detection purpose

    def __init__(self, *args, **kwargs):

        self._admin_session = None

        self._admin_clt_cnx = None

        self._current_session = None

        self._current_clt_cnx = None

        self.repo = None

        self._open_access = set()

        super(CubicWebTC, self).__init__(*args, **kwargs)

    # repository connection handling ###########################################

    def new_access(self, login):

        """provide a new RepoAccess object for a given user

        The access is automatically closed at the end of the test."""

        access = RepoAccess(self.repo, login, self.requestcls)

        self._open_access.add(access)

        return access

    def _close_access(self):

        while self._open_access:

            self._open_access.pop().close()

    @deprecated('[3.19] explicitly use RepoAccess object in test instead')

    def set_cnx(self, cnx):

        """ """

        # XXX we want to deprecate this

        assert getattr(cnx, '_session', None) is not None

        if cnx is self._admin_clt_cnx:

            self._pop_custom_cnx()

        else:

            self._cnxs.add(cnx) # register the cnx to make sure it is removed

            self._current_session = cnx._session

            self._current_clt_cnx = cnx

    @property

    @deprecated('[3.19] explicitly use RepoAccess object in test instead')

    def cnx(self):

        # XXX we want to deprecate this

        clt_cnx = self._current_clt_cnx

        if clt_cnx is None:

            clt_cnx = self._admin_clt_cnx

        return clt_cnx

    def _close_cnx(self):

        """ensure that all cnx used by a test have been closed"""

        for cnx in list(self._cnxs):

            if cnx._open and not cnx._session.closed:

                cnx.rollback()

                cnx.close()

            self._cnxs.remove(cnx)

    @property

    @deprecated('[3.19] explicitly use RepoAccess object in test instead')

    def session(self):

        """return current server side session"""

        # XXX We want to use a srv_connection instead and deprecate this

        # property

        session = self._current_session

        if session is None:

            session = self._admin_session

            # bypassing all sanity to use the same repo cnx in the session we

            # can't call set_cnx as the Connection is not managed by the

            # session.

            session._Session__threaddata.cnx = self._admin_clt_cnx._cnx

        else:

            session._Session__threaddata.cnx = self.cnx._cnx

        session.set_cnxset()

        return session

    @property

    @deprecated('[3.19] explicitly use RepoAccess object in test instead')

    def websession(self):

        return self.session

    @property

    @deprecated('[3.19] explicitly use RepoAccess object in test instead')

    def adminsession(self):

        """return current server side session (using default manager account)"""

        return self._admin_session

    @deprecated('[3.19] explicitly use RepoAccess object in test instead')

    def login(self, login, **kwargs):

        """return a connection for the given login/password"""

        __ = kwargs.pop('autoclose', True) # not used anymore

        if login == self.admlogin:

            # undo any previous login, if we're not used as a context manager

            self.restore_connection()

            return self.cnx

        else:

            if not kwargs:

                kwargs['password'] = str(login)

            clt_cnx = repoapi.connect(self.repo, login, **kwargs)

        self.set_cnx(clt_cnx)

        clt_cnx.__enter__()

        return TestCaseConnectionProxy(self, clt_cnx)

    @deprecated('[3.19] explicitly use RepoAccess object in test instead')

    def restore_connection(self):

        self._pop_custom_cnx()

    def _pop_custom_cnx(self):

        if self._current_clt_cnx is not None:

            if self._current_clt_cnx._open:

                self._current_clt_cnx.close()

            if not  self._current_session.closed:

                self.repo.close(self._current_session.sessionid)

            self._current_clt_cnx = None

            self._current_session = None

    #XXX this doesn't need to a be classmethod anymore

    def _init_repo(self):

        """init the repository and connection to it.

        """

        # setup configuration for test

        self.init_config(self.config)

        # get or restore and working db.

        db_handler = devtools.get_test_db_handler(self.config)

        db_handler.build_db_cache(self.test_db_id, self.pre_setup_database)

        db_handler.restore_database(self.test_db_id)

        self.repo = db_handler.get_repo(startup=True)