unittest_comment.py

from __future__ import with_statement

import re

from cubicweb.devtools.testlib import CubicWebTC
from cubicweb.selectors import traced_selection
from cubicweb.web.views import actions

from cubes.comment import views

class CommentTC(CubicWebTC):
    """Comment"""
    def test_schema(self):
        self.assertEquals(self.schema['comments'].rproperty('Comment', 'BlogEntry', 'composite'),
                          'object')

    def setup_database(self):
        super(CommentTC, self).setup_database()
        self.b = self.execute('INSERT BlogEntry X: X title "yo", X content "qu\'il est beau"').get_entity(0, 0)
        self.c = self.execute('INSERT Comment X: X content "bouh!", X comments B WHERE B is BlogEntry')
        self.create_user('user')

    def test_possible_views(self):
        # comment primary view priority
        rset, req = self.rset_and_req('Comment X')
        self.assertIsInstance(self.vreg['views'].select('primary', req, rset=rset),
                             views.CommentPrimaryView)
        self.assertIsInstance(self.vreg['views'].select('tree', req, rset=rset),
                             views.CommentThreadView)

    def test_possible_actions(self):
        rset, req = self.rset_and_req('Any X WHERE X is BlogEntry')
        self.failUnlessEqual(self.pactions(req, rset),
                             [('edit', actions.ModifyAction),
                              ('managepermission', actions.ManagePermissionsAction),
                              ('addrelated', actions.AddRelatedActions),
                              ('delete', actions.DeleteAction),
                              ('copy', actions.CopyAction),
                              ('reply_comment', views.AddCommentAction)])
        rset, req = self.rset_and_req('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions(req, rset),
                             [('edit', actions.ModifyAction),
                              ('managepermission', actions.ManagePermissionsAction),
                              ('addrelated', actions.AddRelatedActions),
                              ('delete', actions.DeleteAction),
                              ('copy', actions.CopyAction),
                              ('delete_comment', views.DeleteCommentAction),
                              ('edit_comment', views.EditCommentAction),
                              ('reply_comment', views.ReplyCommentAction)])
        cnx = self.login('user')
        rset, req = self.rset_and_req('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions(req, rset),
                             [('addrelated', actions.AddRelatedActions),
                              ('copy', actions.CopyAction),
                              ('reply_comment', views.ReplyCommentAction)])
        rset = self.execute('INSERT Comment X: X content "ho bah non!", X comments B WHERE B is Comment')
        cnx.commit()
        self.failUnlessEqual(self.pactions(rset.req, rset),
                             [('edit', actions.ModifyAction),
                              ('addrelated', actions.AddRelatedActions),
                              ('delete', actions.DeleteAction),
                              ('copy', actions.CopyAction),
                              ('delete_comment', views.DeleteCommentAction),
                              ('edit_comment', views.EditCommentAction),
                              ('reply_comment', views.ReplyCommentAction)])
        cnx.rollback()
        cnx = self.login('anon')
        rset, req = self.rset_and_req('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions(req, rset), [])
        cnx.rollback()

    def test_nonregr_possible_actions(self):
        rset, req = self.rset_and_req('Any B WHERE B is BlogEntry')
        beid = rset[0][0]
        self.execute('INSERT Comment X: X content "Yooo !", X comments B WHERE B eid %s' % beid)
        # now two comments are commenting this blog
        rset, req = self.rset_and_req('Any C WHERE C comments X, X eid %s' % beid)
        self.assertEquals(len(rset), 2)
        self.failUnless(self.vreg['actions'].select('reply_comment', req, rset=rset, row=0))
        self.failUnless(self.vreg['actions'].select('reply_comment', req, rset=rset, row=1))

    def test_add_related_actions(self):
        rset, req = self.rset_and_req('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions_by_cats(req, rset), [])
        cnx = self.login('user')
        rset, req = self.rset_and_req('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions_by_cats(req, rset), [])
        cnx.rollback()
        cnx = self.login('anon')
        rset, req = self.rset_and_req('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions_by_cats(req, rset), [])
        cnx.rollback()

    def test_path(self):
        teid = self.execute('BlogEntry X')[0][0]
        eid1 = self.execute('INSERT Comment X: X content "oijzr", X comments Y WHERE Y is BlogEntry')[0][0]
        eid2 = self.execute('INSERT Comment X: X content "duh?", X comments Y WHERE Y eid %s'%eid1)[0][0]
        comment1 = self.entity('Any X WHERE X eid %(x)s', {'x':eid1}, 'x')
        self.assertEquals(comment1.path(), [teid, eid1])
        self.assertEquals(comment1.root().eid, teid)
        comment2 = self.entity('Any X WHERE X eid %(x)s', {'x':eid2}, 'x')
        self.assertEquals(comment2.path(), [teid, eid1, eid2])
        self.assertEquals(comment2.root().eid, teid)

    def test_fullthreadtext_views(self):
        c = self.entity('Comment X')
        c2eid = self.execute('INSERT Comment X: X content %(text)s, X content_format "text/html", '
                              'X comments %(x)s',
                            {'x': c.eid, 'text': u"""
some long <b>HTML</b> text which <em>should not</em> fit on 80 characters, so i'll add some extra xxxxxxx.
Yeah !"""})[0][0]
        self.commit()
        c2rset= self.execute('Any X WHERE X eid %(x)s', {'x': c2eid}, 'x')
        v = self.vreg['views'].select('fullthreadtext', self.request(),
                                      rset=c2rset, row=0)
        content = v.render(row=0)
        # remove date
        content = re.sub('..../../.. ..:..', '', content)
        self.assertTextEquals(content,
                          """\
> On  - admin wrote :
> bouh!

some long **HTML** text which _should not_ fit on 80 characters, so i'll add
some extra xxxxxxx. Yeah !


i18n_by_author_field: admin
url: http://testing.fr/cubicweb/blogentry/%s""" % self.b.eid)
        # fullthreadtext_descending view
        self.assertTextEquals(re.sub('..../../.. ..:..', '', c.view('fullthreadtext_descending')),
                              '''On  - admin wrote :
bouh!
> On  - admin wrote :
> some long **HTML** text which _should not_ fit on 80 characters, so i\'ll add
> some extra xxxxxxx. Yeah !

''')

class CommentJsonControllerExtensionsTC(CubicWebTC):

    def setup_database(self):
        self.john = self.create_user(u'John')

    def test_add_and_edit_comment(self):
        # add comment
        self.remote_call('add_comment', self.john.eid, u'yo', u'text/plain')
        comment = self.entity('Any C,CT,F WHERE C content CT, C content_format F, '
                              'C comments P, P eid %s' % self.john.eid)
        self.assertEquals(comment.content, u'yo')
        self.assertEquals(comment.content_format, u'text/plain')
        # edit comment
        self.remote_call('edit_comment', comment.eid, u'yipee', u'text/plain')
        comment2 = self.entity('Any C,CT,F WHERE C content CT, C content_format F, '
                               'C comments P, P eid %s' % self.john.eid)
        self.assertEquals(comment.eid, comment2.eid)
        self.assertEquals(comment2.content, u'yipee')
        self.assertEquals(comment2.content_format, u'text/plain')


if __name__ == '__main__':
    from logilab.common.testlib import unittest_main
    unittest_main()