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

"""unit tests for cubicweb.web.views.entities module

:organization: Logilab

:copyright: 2001-2010 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

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

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

from datetime import datetime

from cubicweb import Binary, Unauthorized

from cubicweb.devtools.testlib import CubicWebTC

from cubicweb.mttransforms import HAS_TAL

from cubicweb.entities import fetch_config

class EntityTC(CubicWebTC):

    def test_boolean_value(self):

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

        self.failUnless(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.assertEquals(e.eid, None)

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

        e.eid = 'X'

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

        e.eid = 0

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

        e.eid = 2

        self.assertEquals(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}, ('t','u'))

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

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

        e.copy_relations(oe.eid)

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

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

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

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

        self.assertEquals(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}, ('t','u'))

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

        e.copy_relations(oe.eid)

        self.failIf(e.ecrit_par)

        self.failUnless(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.entity('Any X WHERE X eid %(x)s', {'x':user.eid}, 'x')

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

        self.assertEquals(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.entity('Any X WHERE X eid %(x)s', {'x':usereid}, 'x')

        e.copy_relations(user.eid)

        self.failIf(e.use_email)

        self.failIf(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.fire_transition('deactivate')

        self.commit()

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

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

        e.copy_relations(user.eid)

        self.commit()

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

        self.assertEquals(e.state, 'activated')

    def test_related_cache_both(self):

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

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

        self.commit()

        self.assertEquals(user._related_cache, {})

        email = user.primary_email[0]

        self.assertEquals(sorted(user._related_cache), ['primary_email_subject'])

        self.assertEquals(email._related_cache.keys(), ['primary_email_object'])

        groups = user.in_group

        self.assertEquals(sorted(user._related_cache), ['in_group_subject', 'primary_email_subject'])

        for group in groups:

            self.failIf('in_group_subject' in group._related_cache, group._related_cache.keys())

    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.assertEquals(len(p.related('tags', 'object', limit=2)), 2)

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

    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

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

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

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

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

        # testing basic fetch_attrs attribute

        self.assertEquals(Personne.fetch_rql(user),

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

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

        pfetch_attrs = Personne.fetch_attrs

        sfetch_attrs = Societe.fetch_attrs

        try:

            # testing unknown attributes

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

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

            # testing one non final relation

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

            self.assertEquals(Personne.fetch_rql(user),

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

                              '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.assertEquals(Personne.fetch_rql(user),

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

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

                              'X evaluee AE?, AE modification_date AF')

            # testing one non final relation with recursion

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

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

            self.assertEquals(Personne.fetch_rql(user),

                              'Any X,AA,AB,AC,AD,AE,AF ORDERBY AA ASC,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.assertEquals(Personne.fetch_rql(user), 'Any X,AA,AB ORDERBY AA ASC '

                              '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.assertEquals(Personne.fetch_rql(user),

                              'Any X,AA,AB,AC,AD ORDERBY AA ASC 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.assertEquals(Personne.fetch_rql(user),

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

            # XXX test unauthorized attribute

        finally:

            Personne.fetch_attrs = pfetch_attrs

            Societe.fetch_attrs = sfetch_attrs

    def test_related_rql(self):

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

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

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

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

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

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

        self.assertEquals(p.related_rql('evaluee'),

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

                          'X type AA, X modification_date AB')

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

        # XXX

        self.assertEquals(p.related_rql('evaluee'),

                          'Any X,AA ORDERBY Z DESC '

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

                          'X modification_date AA')

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

        self.assertEquals(tag.related_rql('tags', 'subject'),

                          'Any X,AA ORDERBY Z DESC '

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

                          'X modification_date AA')

        self.assertEquals(tag.related_rql('tags', 'subject', ('Personne',)),

                          'Any X,AA,AB ORDERBY AA ASC '

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

                          'X modification_date AB')

    def test_unrelated_rql_security_1(self):

        user = self.request().user

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

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

                          'WHERE NOT S use_email O, S eid %(x)s, O is EmailAddress, O address AA, O alias AB, O modification_date AC')

        self.create_user('toto')

        self.login('toto')

        user = self.request().user

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

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

                          'WHERE NOT S 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)

        self.assertRaises(Unauthorized, user.unrelated_rql, 'use_email', 'EmailAddress', 'subject')

        self.login('anon')

        user = self.request().user

        self.assertRaises(Unauthorized, user.unrelated_rql, 'use_email', 'EmailAddress', 'subject')

    def test_unrelated_rql_security_2(self):

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

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

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

                          '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')

        #rql = email.unrelated_rql('use_email', 'Person', 'object')[0]

        #self.assertEquals(rql, '')

        self.login('anon')

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

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

        self.assertEquals(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, '

                          'A eid %(B)s, EXISTS(S identity A, NOT A in_group C, C name "guests", C is CWGroup)')

        #rql = email.unrelated_rql('use_email', 'Person', 'object')[0]

        #self.assertEquals(rql, '')

    def test_unrelated_rql_security_nonexistant(self):

        self.login('anon')

        email = self.vreg['etypes'].etype_class('EmailAddress')(self.request())

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

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

                          'WHERE S is CWUser, S login AA, S firstname AB, S surname AC, S modification_date AD, '

                          'A eid %(B)s, EXISTS(S identity A, NOT A in_group C, C name "guests", C is CWGroup)')

    def test_unrelated_base(self):

        req = self.request()

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

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

        related = [r.eid for r in e.tags]

        self.failUnlessEqual(related, [])

        unrelated = [r[0] for r in e.unrelated('tags', 'Personne', 'subject')]

        self.failUnless(p.eid in unrelated)

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

        e = self.entity('Any X WHERE X is Tag')

        unrelated = [r[0] for r in e.unrelated('tags', 'Personne', 'subject')]

        self.failIf(p.eid in unrelated)

    def test_unrelated_limit(self):

        req = self.request()

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

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

        req.create_entity('Personne', nom=u'thenault', prenom=u'sylvain')

        self.assertEquals(len(e.unrelated('tags', 'Personne', 'subject', limit=1)),

                          1)

    def test_unrelated_security(self):

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

        rset = email.unrelated('use_email', 'CWUser', 'object')

        self.assertEquals([x.login for x in rset.entities()], [u'admin', u'anon'])

        user = self.request().user

        rset = user.unrelated('use_email', 'EmailAddress', 'subject')

        self.assertEquals([x.address for x in rset.entities()], [u'hop'])

        self.create_user('toto')

        self.login('toto')

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

        rset = email.unrelated('use_email', 'CWUser', 'object')

        self.assertEquals([x.login for x in rset.entities()], ['toto'])

        user = self.request().user

        rset = user.unrelated('use_email', 'EmailAddress', 'subject')

        self.assertEquals([x.address for x in rset.entities()], ['hop'])

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

        rset = user.unrelated('use_email', 'EmailAddress', 'subject')

        self.assertEquals([x.address for x in rset.entities()], [])

        self.login('anon')

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

        rset = email.unrelated('use_email', 'CWUser', 'object')

        self.assertEquals([x.login for x in rset.entities()], [])

        user = self.request().user

        rset = user.unrelated('use_email', 'EmailAddress', 'subject')

        self.assertEquals([x.address for x in rset.entities()], [])

    def test_unrelated_new_entity(self):

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

        unrelated = [r[0] for r in e.unrelated('in_group', 'CWGroup', 'subject')]

        # should be default groups but owners, i.e. managers, users, guests

        self.assertEquals(len(unrelated), 3)

    def test_printable_value_string(self):

        e = self.request().create_entity('Card', title=u'rest test', content=u'du :eid:`1:*ReST*`',

                            content_format=u'text/rest')

        self.assertEquals(e.printable_value('content'),

                          '<p>du <a class="reference" href="http://testing.fr/cubicweb/cwgroup/guests">*ReST*</a></p>\n')

        e['content'] = 'du <em>html</em> <ref rql="CWUser X">users</ref>'

        e['content_format'] = 'text/html'

        self.assertEquals(e.printable_value('content'),

                          'du <em>html</em> <a href="http://testing.fr/cubicweb/view?rql=CWUser%20X">users</a>')

        e['content'] = 'du *texte*'

        e['content_format'] = 'text/plain'

        self.assertEquals(e.printable_value('content'),

                          '<p>\ndu *texte*\n</p>')

        e['title'] = 'zou'

        e['content'] = '''\

a title

=======

du :eid:`1:*ReST*`'''

        e['content_format'] = 'text/rest'

        self.assertEquals(e.printable_value('content', format='text/plain'),

                          e['content'])

        e['content'] = u'<b>yo (zou éà ;)</b>'

        e['content_format'] = 'text/html'

        self.assertEquals(e.printable_value('content', format='text/plain').strip(),

                          u'**yo (zou éà ;)**')

        if HAS_TAL:

            e['content'] = '<h1 tal:content="self/title">titre</h1>'

            e['content_format'] = 'text/cubicweb-page-template'

            self.assertEquals(e.printable_value('content'),

                              '<h1>zou</h1>')

    def test_printable_value_bytes(self):