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

# 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 six import text_type

from logilab.common import tempattr

from logilab.common.decorators import clear_cache

from cubicweb import Binary

from cubicweb.devtools.testlib import CubicWebTC

from cubicweb.mttransforms import HAS_TAL

from cubicweb.entity import can_use_rest_path

from cubicweb.entities import fetch_config

from cubicweb.uilib import soup2xhtml

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_no_prefill_related_cache_bug(self):

        with self.admin_access.repo_cnx() as cnx:

            usine = cnx.create_entity('Usine', lieu=u'Montbeliard')

            produit = cnx.create_entity('Produit')

            # usine was prefilled in glob_add_entity

            # let's simulate produit creation without prefill

            produit._cw_related_cache.clear()

            # use add_relations

            cnx.add_relations([('fabrique_par', [(produit.eid, usine.eid)])])

            self.assertEqual(1, len(usine.reverse_fabrique_par))

            self.assertEqual(1, len(produit.fabrique_par))

    def test_boolean_value(self):

        with self.admin_access.web_request() as req:

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

            self.assertTrue(e)

    def test_yams_inheritance(self):

        from entities import Note

        with self.admin_access.web_request() as req:

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

            self.assertIsInstance(e, Note)

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

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

    def test_has_eid(self):

        with self.admin_access.web_request() as req:

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

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

        with self.admin_access.web_request() as req:

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

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

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

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

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

            req.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):

        with self.admin_access.web_request() as req:

            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'

            req.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):

        with self.admin_access.web_request() as req:

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

            e = req.execute('Any X WHERE X eid %(x)s', {'x': req.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 = req.execute('INSERT CWUser X: X login "toto", X upassword "toto", X in_group G '

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

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

            e.copy_relations(req.user.eid)

            self.assertFalse(e.use_email)

            self.assertFalse(e.primary_email)

    def test_copy_with_non_initial_state(self):

        with self.admin_access.web_request() as req:

            user = req.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)

            req.cnx.commit()

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

            req.cnx.commit()

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

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

            e.copy_relations(user.eid)

            req.cnx.commit()

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

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

    def test_copy_exclude_computed_relations(self):

        """The `CWUser buddies CWUser` (computed) relation should not be copied.

        """

        with self.admin_access.cnx() as cnx:

            friends = cnx.create_entity('CWGroup', name=u'friends')

            bob = self.create_user(cnx, u'bob', groups=('friends',))

            cnx.create_entity('EmailAddress', address=u'bob@cubicweb.org',

                              reverse_use_email=bob)

            alice = self.create_user(cnx, u'alices', groups=('friends',))

            cnx.commit()

            charles = self.create_user(cnx, u'charles')

            cnx.commit()

            # Just ensure this does not crash (it would if computed relation

            # attempted to be copied).

            charles.copy_relations(bob.eid)

    def test_related_cache_both(self):

        with self.admin_access.web_request() as req:

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

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

            req.cnx.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.assertNotIn('in_group_subject', group._cw_related_cache)

            user.cw_clear_all_caches()

            user.related('in_group', entities=True)

            self.assertIn('in_group_subject', user._cw_related_cache)

            user.cw_clear_all_caches()

            user.related('in_group', targettypes=('CWGroup',), entities=True)

            self.assertNotIn('in_group_subject', user._cw_related_cache)

    def test_related_limit(self):

        with self.admin_access.web_request() as req:

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

            for tag in u'abcd':

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

            req.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_related_targettypes(self):

        with self.admin_access.web_request() as req:

            p = req.create_entity('Personne', nom=u'Loxodonta', prenom=u'Babar')

            n = req.create_entity('Note', type=u'scratch', ecrit_par=p)

            t = req.create_entity('Tag', name=u'a tag', tags=(p, n))

            req.cnx.commit()

        with self.admin_access.web_request() as req:

            t = req.entity_from_eid(t.eid)

            self.assertEqual(2, t.related('tags').rowcount)

            self.assertEqual(1, t.related('tags', targettypes=('Personne',)).rowcount)

            self.assertEqual(1, t.related('tags', targettypes=('Note',)).rowcount)

    def test_cw_instantiate_relation(self):

        with self.admin_access.web_request() as req:

            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.assertCountEqual(t.tags, [])

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

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

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

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

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

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

    def test_cw_instantiate_reverse_relation(self):

        with self.admin_access.web_request() as req:

            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.assertCountEqual(p.reverse_tags, [t1])

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

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

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

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

    def test_fetch_rql(self):

        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:

            with self.admin_access.web_request() as req:

                user = req.user

                # testing basic fetch_attrs attribute

                self.assertEqual(Personne.fetch_rql(user),

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

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

                # testing unknown attributes

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

                self.assertEqual(Personne.fetch_rql(user), 'Any X WHERE X is_instance_of 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_instance_of 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 AB '

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

                                 'AD nom 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 '

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

                                 'AC evaluee AD?, AD modification_date AE, AC nom AF')

                # testing symmetric relation

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

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

                                 'WHERE X is_instance_of Personne, X connait AA?, X nom 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_instance_of 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_instance_of 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',))

        with self.admin_access.web_request() as req:

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

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

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

                             'X modification_date AA, X type AB')

            n = req.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')(req)

            select = tag.cw_related_rqlst('tags', 'subject')

            self.assertEqual(select.as_string(),

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

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

                             'X nom AB')

    def test_related_rql_sort_terms(self):

        with self.admin_access.web_request() as req:

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

            select = tag.cw_related_rqlst('tags', 'subject',

                                          sort_terms=(('nom', True),