# -*- coding: iso-8859-1 -*-

# copyright 2003-2012 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/>.

"""unit tests for module cubicweb.server.repository"""

from __future__ import with_statement

import os

import sys

import threading

import time

import logging

from copy import deepcopy

from datetime import datetime

from logilab.common.testlib import TestCase, unittest_main

from yams.constraints import UniqueConstraint

from cubicweb import (BadConnectionId, RepositoryError, ValidationError,

                      UnknownEid, AuthenticationError, Unauthorized, QueryError)

from cubicweb.predicates import is_instance

from cubicweb.schema import CubicWebSchema, RQLConstraint

from cubicweb.dbapi import connect, multiple_connections_unfix

from cubicweb.devtools.testlib import CubicWebTC

from cubicweb.devtools.repotest import tuplify

from cubicweb.server import repository, hook

from cubicweb.server.sqlutils import SQL_PREFIX

from cubicweb.server.hook import Hook

from cubicweb.server.sources import native

# start name server anyway, process will fail if already running

os.system('pyro-ns >/dev/null 2>/dev/null &')

class RepositoryTC(CubicWebTC):

    """ singleton providing access to a persistent storage for entities

    and relation

    """

    def test_fill_schema(self):

        origshema = self.repo.schema

        try:

            self.repo.schema = CubicWebSchema(self.repo.config.appid)

            self.repo.config._cubes = None # avoid assertion error

            self.repo.config.repairing = True # avoid versions checking

            self.repo.fill_schema()

            table = SQL_PREFIX + 'CWEType'

            namecol = SQL_PREFIX + 'name'

            finalcol = SQL_PREFIX + 'final'

            self.session.set_cnxset()

            cu = self.session.system_sql('SELECT %s FROM %s WHERE %s is NULL' % (

                namecol, table, finalcol))

            self.assertEqual(cu.fetchall(), [])

            cu = self.session.system_sql('SELECT %s FROM %s WHERE %s=%%(final)s ORDER BY %s'

                                         % (namecol, table, finalcol, namecol), {'final': True})

            self.assertEqual(cu.fetchall(), [(u'BigInt',), (u'Boolean',), (u'Bytes',),

                                             (u'Date',), (u'Datetime',),

                                             (u'Decimal',),(u'Float',),

                                             (u'Int',),

                                             (u'Interval',), (u'Password',),

                                             (u'String',),

                                             (u'TZDatetime',), (u'TZTime',), (u'Time',)])

            sql = ("SELECT etype.cw_eid, etype.cw_name, cstr.cw_eid, rel.eid_to "

                   "FROM cw_CWUniqueTogetherConstraint as cstr, "

                   "     relations_relation as rel, "

                   "     cw_CWEType as etype "

                   "WHERE cstr.cw_eid = rel.eid_from "

                   "  AND cstr.cw_constraint_of = etype.cw_eid "

                   "  AND etype.cw_name = 'Personne' "

                   ";")

            cu = self.session.system_sql(sql)

            rows = cu.fetchall()

            self.assertEqual(len(rows), 3)

            self.test_unique_together()

        finally:

            self.repo.set_schema(origshema)

    def test_unique_together(self):

        person = self.repo.schema.eschema('Personne')

        self.assertEqual(len(person._unique_together), 1)

        self.assertItemsEqual(person._unique_together[0],

                                           ('nom', 'prenom', 'inline2'))

    def test_all_entities_have_owner(self):

        self.assertFalse(self.execute('Any X WHERE NOT X owned_by U'))

    def test_all_entities_have_is(self):

        self.assertFalse(self.execute('Any X WHERE NOT X is ET'))

    def test_all_entities_have_cw_source(self):

        self.assertFalse(self.execute('Any X WHERE NOT X cw_source S'))

    def test_connect(self):

        cnxid = self.repo.connect(self.admlogin, password=self.admpassword)

        self.assert_(cnxid)

        self.repo.close(cnxid)

        self.assertRaises(AuthenticationError,

                          self.repo.connect, self.admlogin, password='nimportnawak')

        self.assertRaises(AuthenticationError,

                          self.repo.connect, self.admlogin, password=None)

        self.assertRaises(AuthenticationError,

                          self.repo.connect, None, password=None)

        self.assertRaises(AuthenticationError,

                          self.repo.connect, self.admlogin)

        self.assertRaises(AuthenticationError,

                          self.repo.connect, None)

    def test_execute(self):

        repo = self.repo

        cnxid = repo.connect(self.admlogin, password=self.admpassword)

        repo.execute(cnxid, 'Any X')

        repo.execute(cnxid, 'Any X where X is Personne')

        repo.execute(cnxid, 'Any X where X is Personne, X nom ~= "to"')

        repo.execute(cnxid, 'Any X WHERE X has_text %(text)s', {'text': u'\xe7a'})

        repo.close(cnxid)

    def test_login_upassword_accent(self):

        repo = self.repo

        cnxid = repo.connect(self.admlogin, password=self.admpassword)

        repo.execute(cnxid, 'INSERT CWUser X: X login %(login)s, X upassword %(passwd)s, X in_group G WHERE G name "users"',

                     {'login': u"barnab�", 'passwd': u"h�h�h�".encode('UTF8')})

        repo.commit(cnxid)

        repo.close(cnxid)

        cnxid = repo.connect(u"barnab�", password=u"h�h�h�".encode('UTF8'))

        self.assert_(cnxid)

        repo.close(cnxid)

    def test_rollback_on_commit_error(self):

        cnxid = self.repo.connect(self.admlogin, password=self.admpassword)

        self.repo.execute(cnxid,

                          'INSERT CWUser X: X login %(login)s, X upassword %(passwd)s',

                          {'login': u"tutetute", 'passwd': 'tutetute'})

        self.assertRaises(ValidationError, self.repo.commit, cnxid)

        self.assertFalse(self.repo.execute(cnxid, 'CWUser X WHERE X login "tutetute"'))

        self.repo.close(cnxid)

    def test_rollback_on_execute_validation_error(self):

        class ValidationErrorAfterHook(Hook):

            __regid__ = 'valerror-after-hook'

            __select__ = Hook.__select__ & is_instance('CWGroup')

            events = ('after_update_entity',)

            def __call__(self):

                raise ValidationError(self.entity.eid, {})

        with self.temporary_appobjects(ValidationErrorAfterHook):

            self.assertRaises(ValidationError,

                              self.execute, 'SET X name "toto" WHERE X is CWGroup, X name "guests"')

            self.assertTrue(self.execute('Any X WHERE X is CWGroup, X name "toto"'))

            with self.assertRaises(QueryError) as cm:

                self.commit()

            self.assertEqual(str(cm.exception), 'transaction must be rollbacked')

            self.rollback()

            self.assertFalse(self.execute('Any X WHERE X is CWGroup, X name "toto"'))

    def test_rollback_on_execute_unauthorized(self):

        class UnauthorizedAfterHook(Hook):

            __regid__ = 'unauthorized-after-hook'

            __select__ = Hook.__select__ & is_instance('CWGroup')

            events = ('after_update_entity',)

            def __call__(self):

                raise Unauthorized()

        with self.temporary_appobjects(UnauthorizedAfterHook):

            self.assertRaises(Unauthorized,

                              self.execute, 'SET X name "toto" WHERE X is CWGroup, X name "guests"')

            self.assertTrue(self.execute('Any X WHERE X is CWGroup, X name "toto"'))

            with self.assertRaises(QueryError) as cm:

                self.commit()

            self.assertEqual(str(cm.exception), 'transaction must be rollbacked')

            self.rollback()

            self.assertFalse(self.execute('Any X WHERE X is CWGroup, X name "toto"'))

    def test_close(self):

        repo = self.repo

        cnxid = repo.connect(self.admlogin, password=self.admpassword)

        self.assert_(cnxid)

        repo.close(cnxid)

        self.assertRaises(BadConnectionId, repo.execute, cnxid, 'Any X')

    def test_invalid_cnxid(self):

        self.assertRaises(BadConnectionId, self.repo.execute, 0, 'Any X')

        self.assertRaises(BadConnectionId, self.repo.close, None)

    def test_shared_data(self):

        repo = self.repo

        cnxid = repo.connect(self.admlogin, password=self.admpassword)

        repo.set_shared_data(cnxid, 'data', 4)

        cnxid2 = repo.connect(self.admlogin, password=self.admpassword)

        self.assertEqual(repo.get_shared_data(cnxid, 'data'), 4)

        self.assertEqual(repo.get_shared_data(cnxid2, 'data'), None)

        repo.set_shared_data(cnxid2, 'data', 5)

        self.assertEqual(repo.get_shared_data(cnxid, 'data'), 4)

        self.assertEqual(repo.get_shared_data(cnxid2, 'data'), 5)

        repo.get_shared_data(cnxid2, 'data', pop=True)

        self.assertEqual(repo.get_shared_data(cnxid, 'data'), 4)

        self.assertEqual(repo.get_shared_data(cnxid2, 'data'), None)

        repo.close(cnxid)

        repo.close(cnxid2)

        self.assertRaises(BadConnectionId, repo.get_shared_data, cnxid, 'data')

        self.assertRaises(BadConnectionId, repo.get_shared_data, cnxid2, 'data')

        self.assertRaises(BadConnectionId, repo.set_shared_data, cnxid, 'data', 1)

        self.assertRaises(BadConnectionId, repo.set_shared_data, cnxid2, 'data', 1)

    def test_check_session(self):

        repo = self.repo

        cnxid = repo.connect(self.admlogin, password=self.admpassword)

        self.assertIsInstance(repo.check_session(cnxid), float)

        repo.close(cnxid)

        self.assertRaises(BadConnectionId, repo.check_session, cnxid)

    def test_transaction_base(self):

        repo = self.repo

        cnxid = repo.connect(self.admlogin, password=self.admpassword)

        # check db state

        result = repo.execute(cnxid, 'Personne X')

        self.assertEqual(result.rowcount, 0)

        # rollback entity insertion

        repo.execute(cnxid, "INSERT Personne X: X nom 'bidule'")

        result = repo.execute(cnxid, 'Personne X')

        self.assertEqual(result.rowcount, 1)

        repo.rollback(cnxid)

        result = repo.execute(cnxid, 'Personne X')

        self.assertEqual(result.rowcount, 0, result.rows)

        # commit

        repo.execute(cnxid, "INSERT Personne X: X nom 'bidule'")

        repo.commit(cnxid)

        result = repo.execute(cnxid, 'Personne X')

        self.assertEqual(result.rowcount, 1)

        repo.close(cnxid)

    def test_transaction_base2(self):

        repo = self.repo

        cnxid = repo.connect(self.admlogin, password=self.admpassword)

        # rollback relation insertion

        repo.execute(cnxid, "SET U in_group G WHERE U login 'admin', G name 'guests'")

        result = repo.execute(cnxid, "Any U WHERE U in_group G, U login 'admin', G name 'guests'")

        self.assertEqual(result.rowcount, 1)

        repo.rollback(cnxid)

        result = repo.execute(cnxid, "Any U WHERE U in_group G, U login 'admin', G name 'guests'")

        self.assertEqual(result.rowcount, 0, result.rows)

        repo.close(cnxid)

    def test_transaction_base3(self):

        repo = self.repo

        cnxid = repo.connect(self.admlogin, password=self.admpassword)

        # rollback state change which trigger TrInfo insertion

        session = repo._get_session(cnxid)

        session.set_cnxset()

        user = session.user

        user.cw_adapt_to('IWorkflowable').fire_transition('deactivate')

        rset = repo.execute(cnxid, 'TrInfo T WHERE T wf_info_for X, X eid %(x)s', {'x': user.eid})

        self.assertEqual(len(rset), 1)

        repo.rollback(cnxid)

        rset = repo.execute(cnxid, 'TrInfo T WHERE T wf_info_for X, X eid %(x)s', {'x': user.eid})

        self.assertEqual(len(rset), 0)

        repo.close(cnxid)

    def test_transaction_interleaved(self):

        self.skipTest('implement me')

    def test_close_kill_processing_request(self):

        repo = self.repo

        cnxid = repo.connect(self.admlogin, password=self.admpassword)

        repo.execute(cnxid, 'INSERT CWUser X: X login "toto", X upassword "tutu", X in_group G WHERE G name "users"')

        repo.commit(cnxid)

        lock = threading.Lock()

        lock.acquire()

        # close has to be in the thread due to sqlite limitations

        def close_in_a_few_moment():

            lock.acquire()

            repo.close(cnxid)

        t = threading.Thread(target=close_in_a_few_moment)

        t.start()

        def run_transaction():

            lock.release()

            repo.execute(cnxid, 'DELETE CWUser X WHERE X login "toto"')

            repo.commit(cnxid)

        try:

            with self.assertRaises(Exception) as cm:

                run_transaction()

            self.assertEqual(str(cm.exception), 'try to access connections set on a closed session %s' % cnxid)

        finally:

            t.join()

    def test_initial_schema(self):

        schema = self.repo.schema

        # check order of attributes is respected

        self.assertListEqual([r.type for r in schema.eschema('CWAttribute').ordered_relations()

                               if not r.type in ('eid', 'is', 'is_instance_of', 'identity',

                                                 'creation_date', 'modification_date', 'cwuri',

                                                 'owned_by', 'created_by', 'cw_source',

                                                 'update_permission', 'read_permission',

                                                 'in_basket')],

                              ['relation_type',

                               'from_entity', 'to_entity',

                               'constrained_by',

                               'cardinality', 'ordernum',

                               'indexed', 'fulltextindexed', 'internationalizable',

                               'defaultval', 'description', 'description_format'])

        self.assertEqual(schema.eschema('CWEType').main_attribute(), 'name')

        self.assertEqual(schema.eschema('State').main_attribute(), 'name')

        constraints = schema.rschema('name').rdef('CWEType', 'String').constraints

        self.assertEqual(len(constraints), 2)

        for cstr in constraints[:]:

            if isinstance(cstr, UniqueConstraint):

                constraints.remove(cstr)

                break

        else:

            self.fail('unique constraint not found')

        sizeconstraint = constraints[0]

        self.assertEqual(sizeconstraint.min, None)

        self.assertEqual(sizeconstraint.max, 64)

        constraints = schema.rschema('relation_type').rdef('CWAttribute', 'CWRType').constraints

        self.assertEqual(len(constraints), 1)

        cstr = constraints[0]

        self.assert_(isinstance(cstr, RQLConstraint))

        self.assertEqual(cstr.expression, 'O final TRUE')

        ownedby = schema.rschema('owned_by')

        self.assertEqual(ownedby.objects('CWEType'), ('CWUser',))

    def test_pyro(self):

        import Pyro

        Pyro.config.PYRO_MULTITHREADED = 0

        done = []

        # the client part has to be in the thread due to sqlite limitations

        t = threading.Thread(target=self._pyro_client, args=(done,))

        try:

            daemon = self.repo.pyro_register()

            t.start()