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

# 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 cubicweb.web.views.entities module"""

from datetime import datetime

from logilab.common import tempattr

from logilab.common.decorators import clear_cache

from cubicweb import Binary, Unauthorized

from cubicweb.devtools.testlib import CubicWebTC

from cubicweb.mttransforms import HAS_TAL

from cubicweb.entities import fetch_config

from cubicweb.uilib import soup2xhtml

from cubicweb.schema import RQLVocabularyConstraint, RRQLExpression

class EntityTC(CubicWebTC):

    def setUp(self):

        super(EntityTC, self).setUp()

        self.backup_dict = {}

        for cls in self.vreg['etypes'].iter_classes():

            self.backup_dict[cls] = (cls.fetch_attrs, cls.cw_fetch_order)

    def tearDown(self):

        super(EntityTC, self).tearDown()

        for cls in self.vreg['etypes'].iter_classes():

            cls.fetch_attrs, cls.cw_fetch_order = self.backup_dict[cls]

    def test_boolean_value(self):

        e = self.vreg['etypes'].etype_class('CWUser')(self.request())

        self.assertTrue(e)

    def test_yams_inheritance(self):

        from entities import Note

        e = self.vreg['etypes'].etype_class('SubNote')(self.request())

        self.assertIsInstance(e, Note)

        e2 = self.vreg['etypes'].etype_class('SubNote')(self.request())

        self.assertIs(e.__class__, e2.__class__)

    def test_has_eid(self):

        e = self.vreg['etypes'].etype_class('CWUser')(self.request())

        self.assertEqual(e.eid, None)

        self.assertEqual(e.has_eid(), False)

        e.eid = 'X'

        self.assertEqual(e.has_eid(), False)

        e.eid = 0

        self.assertEqual(e.has_eid(), True)

        e.eid = 2

        self.assertEqual(e.has_eid(), True)

    def test_copy(self):

        req = self.request()

        req.create_entity('Tag', name=u'x')

        p = req.create_entity('Personne', nom=u'toto')

        oe = req.create_entity('Note', type=u'x')

        self.execute('SET T ecrit_par U WHERE T eid %(t)s, U eid %(u)s',

                     {'t': oe.eid, 'u': p.eid})

        self.execute('SET TAG tags X WHERE X eid %(x)s', {'x': oe.eid})

        e = req.create_entity('Note', type=u'z')

        e.copy_relations(oe.eid)

        self.assertEqual(len(e.ecrit_par), 1)

        self.assertEqual(e.ecrit_par[0].eid, p.eid)

        self.assertEqual(len(e.reverse_tags), 1)

        # check meta-relations are not copied, set on commit

        self.assertEqual(len(e.created_by), 0)

    def test_copy_with_nonmeta_composite_inlined(self):

        req = self.request()

        p = req.create_entity('Personne', nom=u'toto')

        oe = req.create_entity('Note', type=u'x')

        self.schema['ecrit_par'].rdef('Note', 'Personne').composite = 'subject'

        self.execute('SET T ecrit_par U WHERE T eid %(t)s, U eid %(u)s',

                     {'t': oe.eid, 'u': p.eid})

        e = req.create_entity('Note', type=u'z')

        e.copy_relations(oe.eid)

        self.assertFalse(e.ecrit_par)

        self.assertTrue(oe.ecrit_par)

    def test_copy_with_composite(self):

        user = self.user()

        adeleid = self.execute('INSERT EmailAddress X: X address "toto@logilab.org", U use_email X WHERE U login "admin"')[0][0]

        e = self.execute('Any X WHERE X eid %(x)s', {'x': user.eid}).get_entity(0, 0)

        self.assertEqual(e.use_email[0].address, "toto@logilab.org")

        self.assertEqual(e.use_email[0].eid, adeleid)

        usereid = self.execute('INSERT CWUser X: X login "toto", X upassword "toto", X in_group G '

                               'WHERE G name "users"')[0][0]

        e = self.execute('Any X WHERE X eid %(x)s', {'x': usereid}).get_entity(0, 0)

        e.copy_relations(user.eid)

        self.assertFalse(e.use_email)

        self.assertFalse(e.primary_email)

    def test_copy_with_non_initial_state(self):

        user = self.user()

        user = self.execute('INSERT CWUser X: X login "toto", X upassword %(pwd)s, X in_group G WHERE G name "users"',

                           {'pwd': 'toto'}).get_entity(0, 0)

        self.commit()

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

        self.commit()

        eid2 = self.execute('INSERT CWUser X: X login "tutu", X upassword %(pwd)s', {'pwd': 'toto'})[0][0]

        e = self.execute('Any X WHERE X eid %(x)s', {'x': eid2}).get_entity(0, 0)

        e.copy_relations(user.eid)

        self.commit()

        e.cw_clear_relation_cache('in_state', 'subject')

        self.assertEqual(e.cw_adapt_to('IWorkflowable').state, 'activated')

    def test_related_cache_both(self):

        user = self.execute('Any X WHERE X eid %(x)s', {'x':self.user().eid}).get_entity(0, 0)

        adeleid = self.execute('INSERT EmailAddress X: X address "toto@logilab.org", U use_email X WHERE U login "admin"')[0][0]

        self.commit()

        self.assertEqual(user._cw_related_cache, {})

        email = user.primary_email[0]

        self.assertEqual(sorted(user._cw_related_cache), ['primary_email_subject'])

        self.assertEqual(list(email._cw_related_cache), ['primary_email_object'])

        groups = user.in_group

        self.assertEqual(sorted(user._cw_related_cache), ['in_group_subject', 'primary_email_subject'])

        for group in groups:

            self.assertFalse('in_group_subject' in group._cw_related_cache, list(group._cw_related_cache))

    def test_related_limit(self):

        req = self.request()

        p = req.create_entity('Personne', nom=u'di mascio', prenom=u'adrien')

        for tag in u'abcd':

            req.create_entity('Tag', name=tag)

        self.execute('SET X tags Y WHERE X is Tag, Y is Personne')

        self.assertEqual(len(p.related('tags', 'object', limit=2)), 2)

        self.assertEqual(len(p.related('tags', 'object')), 4)

        p.cw_clear_all_caches()

        self.assertEqual(len(p.related('tags', 'object', entities=True, limit=2)), 2)

        self.assertEqual(len(p.related('tags', 'object', entities=True)), 4)

    def test_cw_instantiate_relation(self):

        req = self.request()

        p1 = req.create_entity('Personne', nom=u'di')

        p2 = req.create_entity('Personne', nom=u'mascio')

        t = req.create_entity('Tag', name=u't0', tags=[])

        self.assertItemsEqual(t.tags, [])

        t = req.create_entity('Tag', name=u't1', tags=p1)

        self.assertItemsEqual(t.tags, [p1])

        t = req.create_entity('Tag', name=u't2', tags=p1.eid)

        self.assertItemsEqual(t.tags, [p1])

        t = req.create_entity('Tag', name=u't3', tags=[p1, p2.eid])

        self.assertItemsEqual(t.tags, [p1, p2])

    def test_cw_instantiate_reverse_relation(self):

        req = self.request()

        t1 = req.create_entity('Tag', name=u't1')

        t2 = req.create_entity('Tag', name=u't2')

        p = req.create_entity('Personne', nom=u'di mascio', reverse_tags=t1)

        self.assertItemsEqual(p.reverse_tags, [t1])

        p = req.create_entity('Personne', nom=u'di mascio', reverse_tags=t1.eid)

        self.assertItemsEqual(p.reverse_tags, [t1])

        p = req.create_entity('Personne', nom=u'di mascio', reverse_tags=[t1, t2.eid])

        self.assertItemsEqual(p.reverse_tags, [t1, t2])

    def test_fetch_rql(self):

        user = self.user()

        Personne = self.vreg['etypes'].etype_class('Personne')

        Societe = self.vreg['etypes'].etype_class('Societe')

        Note = self.vreg['etypes'].etype_class('Note')

        peschema = Personne.e_schema

        seschema = Societe.e_schema

        torestore = []

        for rdef, card in [(peschema.subjrels['travaille'].rdef(peschema, seschema), '1*'),

                           (peschema.subjrels['connait'].rdef(peschema, peschema), '11'),

                           (peschema.subjrels['evaluee'].rdef(peschema, Note.e_schema), '1*'),

                           (seschema.subjrels['evaluee'].rdef(seschema, Note.e_schema), '1*')]:

            cm = tempattr(rdef, 'cardinality', card)

            cm.__enter__()

            torestore.append(cm)

        try:

            # testing basic fetch_attrs attribute

            self.assertEqual(Personne.fetch_rql(user),

                              'Any X,AA,AB,AC ORDERBY AA '

                              'WHERE X is Personne, X nom AA, X prenom AB, X modification_date AC')

            # testing unknown attributes

            Personne.fetch_attrs = ('bloug', 'beep')

            self.assertEqual(Personne.fetch_rql(user), 'Any X WHERE X is Personne')

            # testing one non final relation

            Personne.fetch_attrs = ('nom', 'prenom', 'travaille')

            self.assertEqual(Personne.fetch_rql(user),

                              'Any X,AA,AB,AC,AD ORDERBY AA '

                              'WHERE X is Personne, X nom AA, X prenom AB, X travaille AC?, AC nom AD')

            # testing two non final relations

            Personne.fetch_attrs = ('nom', 'prenom', 'travaille', 'evaluee')

            self.assertEqual(Personne.fetch_rql(user),

                             'Any X,AA,AB,AC,AD,AE ORDERBY AA '

                             'WHERE X is Personne, X nom AA, X prenom AB, X travaille AC?, AC nom AD, '

                             'X evaluee AE?')

            # testing one non final relation with recursion

            Personne.fetch_attrs = ('nom', 'prenom', 'travaille')

            Societe.fetch_attrs = ('nom', 'evaluee')

            self.assertEqual(Personne.fetch_rql(user),

                              'Any X,AA,AB,AC,AD,AE,AF ORDERBY AA,AF DESC '

                              'WHERE X is Personne, X nom AA, X prenom AB, X travaille AC?, AC nom AD, '

                              'AC evaluee AE?, AE modification_date AF'

                              )

            # testing symmetric relation

            Personne.fetch_attrs = ('nom', 'connait')

            self.assertEqual(Personne.fetch_rql(user), 'Any X,AA,AB ORDERBY AA '

                              'WHERE X is Personne, X nom AA, X connait AB?')

            # testing optional relation

            peschema.subjrels['travaille'].rdef(peschema, seschema).cardinality = '?*'

            Personne.fetch_attrs = ('nom', 'prenom', 'travaille')

            Societe.fetch_attrs = ('nom',)

            self.assertEqual(Personne.fetch_rql(user),

                              'Any X,AA,AB,AC,AD ORDERBY AA WHERE X is Personne, X nom AA, X prenom AB, X travaille AC?, AC nom AD')

            # testing relation with cardinality > 1

            peschema.subjrels['travaille'].rdef(peschema, seschema).cardinality = '**'

            self.assertEqual(Personne.fetch_rql(user),

                              'Any X,AA,AB ORDERBY AA WHERE X is Personne, X nom AA, X prenom AB')

            # XXX test unauthorized attribute

        finally:

            # fetch_attrs restored by generic tearDown

            for cm in torestore:

                cm.__exit__(None, None, None)

    def test_related_rql_base(self):

        Personne = self.vreg['etypes'].etype_class('Personne')

        Note = self.vreg['etypes'].etype_class('Note')

        SubNote = self.vreg['etypes'].etype_class('SubNote')

        self.assertTrue(issubclass(self.vreg['etypes'].etype_class('SubNote'), Note))

        Personne.fetch_attrs, Personne.cw_fetch_order = fetch_config(('nom', 'type'))

        Note.fetch_attrs, Note.cw_fetch_order = fetch_config(('type',))

        SubNote.fetch_attrs, SubNote.cw_fetch_order = fetch_config(('type',))

        p = self.request().create_entity('Personne', nom=u'pouet')

        self.assertEqual(p.cw_related_rql('evaluee'),

                         'Any X,AA,AB ORDERBY AA WHERE E eid %(x)s, E evaluee X, '

                         'X type AA, X modification_date AB')

        n = self.request().create_entity('Note')

        self.assertEqual(n.cw_related_rql('evaluee', role='object',

                                          targettypes=('Societe', 'Personne')),

                         "Any X,AA ORDERBY AB DESC WHERE E eid %(x)s, X evaluee E, "

                         "X is IN(Personne, Societe), X nom AA, "

                         "X modification_date AB")

        Personne.fetch_attrs, Personne.cw_fetch_order = fetch_config(('nom', ))

        # XXX

        self.assertEqual(p.cw_related_rql('evaluee'),

                          'Any X,AA ORDERBY AA DESC '

                          'WHERE E eid %(x)s, E evaluee X, X modification_date AA')

        tag = self.vreg['etypes'].etype_class('Tag')(self.request())

        self.assertEqual(tag.cw_related_rql('tags', 'subject'),

                          'Any X,AA ORDERBY AA DESC '

                          'WHERE E eid %(x)s, E tags X, X modification_date AA')

        self.assertEqual(tag.cw_related_rql('tags', 'subject', ('Personne',)),

                          'Any X,AA,AB ORDERBY AA '

                          'WHERE E eid %(x)s, E tags X, X is Personne, X nom AA, '

                          'X modification_date AB')

    def test_related_rql_ambiguous_cant_use_fetch_order(self):

        tag = self.vreg['etypes'].etype_class('Tag')(self.request())

        for ttype in self.schema['tags'].objects():

            self.vreg['etypes'].etype_class(ttype).fetch_attrs = ('modification_date',)

        self.assertEqual(tag.cw_related_rql('tags', 'subject'),

                          'Any X,AA ORDERBY AA DESC '

                          'WHERE E eid %(x)s, E tags X, X modification_date AA')

    def test_related_rql_fetch_ambiguous_rtype(self):

        soc_etype = self.vreg['etypes'].etype_class('Societe')

        soc = soc_etype(self.request())

        soc_etype.fetch_attrs = ('fournit',)

        self.vreg['etypes'].etype_class('Service').fetch_attrs = ('fabrique_par',)

        self.vreg['etypes'].etype_class('Produit').fetch_attrs = ('fabrique_par',)

        self.vreg['etypes'].etype_class('Usine').fetch_attrs = ('lieu',)

        self.vreg['etypes'].etype_class('Personne').fetch_attrs = ('nom',)

        self.assertEqual(soc.cw_related_rql('fournit', 'subject'),

                         'Any X,A WHERE E eid %(x)s, E fournit X, X fabrique_par A')

    def test_unrelated_rql_security_1_manager(self):

        user = self.request().user

        rql = user.cw_unrelated_rql('use_email', 'EmailAddress', 'subject')[0]

        self.assertEqual(rql, 'Any O,AA,AB,AC ORDERBY AC DESC '

                         'WHERE NOT A use_email O, S eid %(x)s, '

                         'O is EmailAddress, O address AA, O alias AB, O modification_date AC')

    def test_unrelated_rql_security_1_user(self):

        req = self.request()

        self.create_user(req, 'toto')

        self.login('toto')

        user = req.user

        rql = user.cw_unrelated_rql('use_email', 'EmailAddress', 'subject')[0]

        self.assertEqual(rql, 'Any O,AA,AB,AC ORDERBY AC DESC '

                         'WHERE NOT A use_email O, S eid %(x)s, '

                         'O is EmailAddress, O address AA, O alias AB, O modification_date AC')

        user = self.execute('Any X WHERE X login "admin"').get_entity(0, 0)

        rql = user.cw_unrelated_rql('use_email', 'EmailAddress', 'subject')[0]

        self.assertEqual(rql, 'Any O,AA,AB,AC ORDERBY AC DESC '

                         'WHERE NOT A use_email O, S eid %(x)s, '

                         'O is EmailAddress, O address AA, O alias AB, O modification_date AC, AD eid %(AE)s, '

                         'EXISTS(S identity AD, NOT AD in_group AF, AF name "guests", AF is CWGroup), A is CWUser')

    def test_unrelated_rql_security_1_anon(self):

        self.login('anon')

        user = self.request().user

        rql = user.cw_unrelated_rql('use_email', 'EmailAddress', 'subject')[0]

        self.assertEqual(rql, 'Any O,AA,AB,AC ORDERBY AC DESC '

                         'WHERE NOT A use_email O, S eid %(x)s, '

                         'O is EmailAddress, O address AA, O alias AB, O modification_date AC, AD eid %(AE)s, '

                         'EXISTS(S identity AD, NOT AD in_group AF, AF name "guests", AF is CWGroup), A is CWUser')

    def test_unrelated_rql_security_2(self):

        email = self.execute('INSERT EmailAddress X: X address "hop"').get_entity(0, 0)

        rql = email.cw_unrelated_rql('use_email', 'CWUser', 'object')[0]

        self.assertEqual(rql, 'Any S,AA,AB,AC,AD ORDERBY AA '

                         'WHERE NOT S use_email O, O eid %(x)s, S is CWUser, '

                         'S login AA, S firstname AB, S surname AC, S modification_date AD')

        self.login('anon')

        rperms = self.schema['EmailAddress'].permissions['read']

        clear_cache(self.schema['EmailAddress'], 'get_groups')

        clear_cache(self.schema['EmailAddress'], 'get_rqlexprs')

        self.schema['EmailAddress'].permissions['read'] = ('managers', 'users', 'guests',)