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

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

"""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

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

from cubicweb.schema import  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_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_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 AA '

                                 'WHERE X is_instance_of 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_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 AA '

                                 'WHERE X is_instance_of 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_instance_of 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_instance_of 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_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 AA WHERE E eid %(x)s, E evaluee X, '

                             'X type AA, X modification_date 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)

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

        with self.admin_access.web_request() as req:

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

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

        etvreg = self.vreg['etypes']

        soc_etype = etvreg.etype_class('Societe')

        with self.admin_access.web_request() as req:

            soc = soc_etype(req)

            soc_etype.fetch_attrs = ('fournit',)

            etvreg.etype_class('Service').fetch_attrs = ('fabrique_par',)

            etvreg.etype_class('Produit').fetch_attrs = ('fabrique_par',)

            etvreg.etype_class('Usine').fetch_attrs = ('lieu',)

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

        with self.admin_access.web_request() as req: