source: products/qPloneComments/tags/2.3/tests/testQPloneCommentsCommenting.py @ 1591

#
# Test adding comments possibility on switching on/off moderation
#

import os, sys, string
if __name__ == '__main__':
    execfile(os.path.join(sys.path[0], 'framework.py'))

from Products.PloneTestCase import PloneTestCase
from Products.CMFCore.utils import getToolByName
from zExceptions import Unauthorized
import re

PRODUCT = 'qPloneComments'
USERS = {# Common Members
         'admin':{'passw': 'secret_admin', 'roles': ['Manager']},
         'owner':{'passw': 'secret_owner', 'roles': ['Owner']},
         'member':{'passw': 'secret_member', 'roles': ['Member']},
         'reviewer':{'passw': 'secret_reviewer', 'roles': ['Reviewer']},
         # Members for discussion manager group
         'dm_admin':{'passw': 'secret_dm_admin', 'roles': ['Manager']},
         'dm_owner':{'passw': 'secret_dm_owner', 'roles': ['Owner']},
         'dm_member':{'passw': 'secret_dm_member', 'roles': ['Member']},
         'dm_reviewer':{'passw': 'secret_dm_reviewer', 'roles': ['Reviewer']},
        }
COMMON_USERS_IDS = [u for u in USERS.keys() if not u.startswith('dm_')]
COMMON_USERS_IDS.append('anonym')
DM_USERS_IDS = [u for u in USERS.keys() if u.startswith('dm_')]

PloneTestCase.installProduct(PRODUCT)
PloneTestCase.setupPloneSite()


class TestCommBase(PloneTestCase.FunctionalTestCase):

    def afterSetUp(self):
        self.loginAsPortalOwner()
        self.request = self.app.REQUEST

        self.qi = getToolByName(self.portal, 'portal_quickinstaller', None)
        self.qi.installProduct(PRODUCT)
        # VERY IMPORTANT to guarantee product skin's content visibility
        self._refreshSkinData()

        # Add all users
        self.membership = getToolByName(self.portal, 'portal_membership', None)
        for user_id in USERS.keys():
            self.membership.addMember(user_id, USERS[user_id]['passw'] , USERS[user_id]['roles'], [])
        
        # Add users to Discussion Manager group
        portal_groups = getToolByName(self.portal, 'portal_groups')
        dm_group = portal_groups.getGroupById('DiscussionManager')
        dm_users = [dm_group.addMember(u) for u in DM_USERS_IDS]

        # Allow discussion for Document
        portal_types = getToolByName(self.portal, 'portal_types', None)
        doc_fti = portal_types.getTypeInfo('Document')
        doc_fti._updateProperty('allow_discussion', 1)

        # Add testing documents to portal. Add one document for avery user.
        # For testing behaviors, where made some changes to document state it's more usefull.
        self.discussion = getToolByName(self.portal, 'portal_discussion', None)
        self.all_users_id = DM_USERS_IDS + COMMON_USERS_IDS
        for user_id in self.all_users_id:
            doc_id = 'doc_%s' % user_id
            self.portal.invokeFactory('Document', id=doc_id)
            doc_obj = getattr(self.portal, doc_id)
            doc_obj.edit(text_format='plain', text='hello world from %s' % doc_id)
            # Create talkback for document and Add comment to doc_obj
            self.discussion.getDiscussionFor(doc_obj)
            doc_obj.discussion_reply('A Reply for %s' % doc_id,'text of reply for %s' % doc_id)


class TestMixinAnonymOn:

    def afterSetUp(self):
        pass

    def testAddCommentToDocAnonymUsers(self):
        # ADDING COMMENTS MUST ALLOWED for anonymous users
        self.login('dm_admin')
        doc_obj = getattr(self.portal, "doc_anonym")
        replies_before = len(self.discussion.getDiscussionFor(doc_obj).getReplies())
        # Create talkback for document and Add comment
        self.logout()
        doc_obj.discussion_reply("Anonym reply", "text of 'anonym' reply")
        self.login('dm_admin')
        replies_after = len(self.discussion.getDiscussionFor(doc_obj).getReplies())
        self.assert_(replies_after-replies_before, "Anonymous user CAN'T really add comment in terned ON *Anonymous commenting mode*.")

    def testAddCommentToDocNotAnonymUsers(self):
        # All users CAN ADD COMMENTS
        not_anonym_users = [u for u in self.all_users_id if not u=='anonym']
        failed_users = []
        for u in not_anonym_users:
            self.login('dm_admin')
            doc_id = "doc_%s" % u
            doc_obj = getattr(self.portal, doc_id)
            replies_before = self.discussion.getDiscussionFor(doc_obj).getReplies()
            self.login(u)
            # Create talkback for document and Add comment
            doc_obj.discussion_reply("%s's reply" % u, "text of '%s' reply" % u)
            # Check is comment added
            self.login('dm_admin')
            replies_after = self.discussion.getDiscussionFor(doc_obj).getReplies()
            disparity = len(replies_after) - len(replies_before)
            if not disparity:
                failed_users.append(u)
        self.assert_(not failed_users, "%s - user(s) can not really add comment" % failed_users)


class TestMixinAnonymOff:

    def afterSetUp(self):
        all_users_id = DM_USERS_IDS + COMMON_USERS_IDS
        self.not_like_anonym = ['admin', 'member', 'dm_admin', 'dm_member']
        self.like_anonym = [u for u in all_users_id if u not in self.not_like_anonym]


    def testAddCommentToDocLikeAnonymUsers(self):
        # ADDING COMMENTS MUST REFUSED for anonymous users
        failed_users = []
        for u in self.like_anonym:
            self.login('dm_admin')
            doc_obj = getattr(self.portal, "doc_%s" % u)
            replies_before = self.discussion.getDiscussionFor(doc_obj).getReplies()
            # Create talkback for document and Add comment
            if u=='anonym':
                self.logout()
            else:
                self.login(u)
            self.assertRaises(Unauthorized, doc_obj.discussion_reply, "%s's reply" % u, "text of '%s' reply" % u)
            self.login('dm_admin')
            replies_after = self.discussion.getDiscussionFor(doc_obj).getReplies()
            disparity = len(replies_after) - len(replies_before)
            if disparity:
                failed_users.append(u)
        self.assert_(not failed_users, "%s user(s) CAN really add comment in terned OFF *Anonymous commenting mode*." % failed_users)


    def testAddCommentToDocNotLikeAnonymUsers(self):
        # All users CAN ADD COMMENTS
        failed_users = []
        for u in self.not_like_anonym:
            self.login('dm_admin')
            doc_id = "doc_%s" % u
            doc_obj = getattr(self.portal, doc_id)
            replies_before = self.discussion.getDiscussionFor(doc_obj).getReplies()
            self.login(u)
            # Create talkback for document and Add comment
            doc_obj.discussion_reply("%s's reply" % u, "text of '%s' reply" % u)
            # Check is comment added
            self.login('dm_admin')
            replies_after = self.discussion.getDiscussionFor(doc_obj).getReplies()
            disparity = len(replies_after) - len(replies_before)
            if not disparity:
                failed_users.append(u)
        self.assert_(not failed_users, "%s - user(s) can not really add commentin terned OFF *Anonymous commenting mode*." % failed_users)


class TestMixinModerationOn:

    def afterSetUp(self):
        # Get Moderation state
        pp = getToolByName(self.portal, 'portal_properties')
        config_ps = getattr(pp, 'qPloneComments', None)
        EnableAnonymComm = getattr(config_ps, "enable_anonymous_commenting")
        # Group users depending on Anonymous commenting enabling/disabling
        if EnableAnonymComm:
            self.allowable_dm_users = DM_USERS_IDS
            self.allowable_common_users = COMMON_USERS_IDS
            self.illegal_dm_users = []
            self.illegal_common_users = []
        else:
            self.allowable_dm_users = ['dm_admin', 'dm_member']
            self.allowable_common_users = ['admin', 'member']
            self.illegal_dm_users = [u for u in DM_USERS_IDS if not u in self.allowable_dm_users]
            self.illegal_common_users = [u for u in COMMON_USERS_IDS if not u in self.allowable_common_users]

    """
    def testAddCommentToNotPublishedReplyDMUsers(self):
        # DiscussionManager's group's members with Manager or Member roles CAN ADD COMMENTS
        # to reply IN ANY STATE (published/not published)
        failed_users = []
        for u in self.allowable_dm_users:
            self.login(u)
            doc_obj = getattr(self.portal, "doc_%s" % u)
            # Get reply to this document
            reply = self.discussion.getDiscussionFor(doc_obj).getReplies()[0]
            # Create talkback for reply and Add comment
            self.discussion.getDiscussionFor(reply)
            reply.discussion_reply("%s's reply" % u, "text of '%s' reply" % u)
            replies_to_reply = self.discussion.getDiscussionFor(reply).getReplies()
            if not replies_to_reply:
                failed_users.append(u)
        self.assert_(not failed_users, "%s - member(s) of DiscussionManager group CAN'T really ADD comment" % failed_users)
        # This is actual only in terned OFF *Anonymous commenting mode*
        failed_users = []
        for u in self.illegal_dm_users:
            self.login(u)
            doc_obj = getattr(self.portal, "doc_%s" % u)
            # Get reply to this document
            reply = self.discussion.getDiscussionFor(doc_obj).getReplies()[0]
            # Create talkback for reply and Add comment
            self.discussion.getDiscussionFor(reply)
            self.assertRaises(Unauthorized, reply.discussion_reply, "%s's reply" % u, "text of '%s' reply" % u)
            replies_to_reply = self.discussion.getDiscussionFor(reply).getReplies()
            if replies_to_reply:
                failed_users.append(u)
        self.assert_(not failed_users, "%s user(s) CAN really add comment in terned OFF *Anonymous commenting mode*." % failed_users)


    def testAddCommentToNotPublishedReplyNotDMUsers(self):
        # Users without DiscussionManager role CAN'T ACCESS an so ADD COMMENTS
        # TO NOT PUBLISHED reply.
        manager = 'dm_admin'
        for u in COMMON_USERS_IDS:
            self.login(manager)
            doc_obj = getattr(self.portal, "doc_%s" % u)
            reply = self.discussion.getDiscussionFor(doc_obj).getReplies()[0]
            reply_to_reply = self.discussion.getDiscussionFor(reply).getReplies()
            reply_to_reply_before = len(reply_to_reply)
            if u=='anonym':
                self.logout()
            else:
                self.logout()
                self.login(u)
            # On adding reply to not published reply MUST generte Unauthorized exception
            self.assertRaises(Unauthorized, reply.discussion_reply, "Reply %s" % u, "text of %s reply" % u)
    """

    def testAddCommentToPublishedReplyALLUsers(self):
        # All users CAN ADD COMMENTS to published reply
        manager = 'dm_admin'
        allowable_users = self.allowable_dm_users + self.allowable_common_users
        illegal_users = self.illegal_dm_users + self.illegal_common_users
        all_users = allowable_users + illegal_users
        # 1. Publish comments
        self.login(manager)
        for u in all_users:
            doc_obj = getattr(self.portal, "doc_%s" % u)
            reply = self.discussion.getDiscussionFor(doc_obj).getReplies()[0]
            reply.discussion_publish_comment()
        # 2.Check adding reply to reply for allowable users
        failed_users = []
        for u in allowable_users:
            if u=='anonym':
                self.logout()
            else:
                self.logout()
                self.login(u)
            # Create talkback for document and Add comment
            self.discussion.getDiscussionFor(reply)
            reply.discussion_reply("Reply %s" % u, "text of %s reply" % u)
            # Check is comment added
            self.login(manager)
            reply_to_reply = self.discussion.getDiscussionFor(reply).getReplies()
            if not reply_to_reply:
                failed_users.append(u)
        self.assert_(not failed_users, "%s - user(s) can not really add comment to PUBLISHED reply" % failed_users)
        # 3.Check adding reply to reply for illegal users
        for u in illegal_users:
            if u=='anonym':
                self.logout()
            else:
                self.login(u)
            # On adding reply to not published reply MUST generte Unauthorized exception
            self.discussion.getDiscussionFor(reply)
            self.assertRaises(Unauthorized, reply.discussion_reply, "Reply %s" % u, "text of %s reply" % u)


class TestMixinModerationOff:

    def afterSetUp(self):
        # Get Moderation state
        pp = getToolByName(self.portal, 'portal_properties')
        config_ps = getattr(pp, 'qPloneComments', None)
        EnableAnonymComm = getattr(config_ps, "enable_anonymous_commenting")
        # Group users depending on Anonymous commenting enabling/disabling
        if EnableAnonymComm:
            self.allowable_users = DM_USERS_IDS + COMMON_USERS_IDS
            self.illegal_users = []
        else:
            self.allowable_users = ['dm_admin', 'dm_member', 'admin', 'member']
            self.illegal_users = [u for u in self.all_users_id if not u in self.allowable_users]

        # Add testing document to portal in Moderation OFF mode.
        self.discussion = getToolByName(self.portal, 'portal_discussion', None)
        self.doc_moder_off_id = 'doc_moderation_off'
        self.portal.invokeFactory('Document', id=self.doc_moder_off_id)
        doc_obj = getattr(self.portal, self.doc_moder_off_id)
        doc_obj.edit(text_format='plain', text='hello world from in moderation off mode')
        # Create talkback for document and Add comment to 'doc_moderatio_off'
        self.discussion.getDiscussionFor(doc_obj)
        doc_obj.discussion_reply("A Reply to '%s'" % self.doc_moder_off_id,"text of reply to '%s'" % self.doc_moder_off_id)
            

    def testAddCommentToReplyAllowableUsers(self):
        # Users CAN ADD COMMENTS
        failed_users = []
        for u in self.allowable_users:
            if u=='anonym':
                self.logout()
            else:
                self.login(u)
            doc_obj = getattr(self.portal, self.doc_moder_off_id)
            # Get reply to this document
            reply_to_doc = self.discussion.getDiscussionFor(doc_obj).getReplies()[0]
            # Create talkback for reply and Add comment
            replies_before = self.discussion.getDiscussionFor(reply_to_doc).getReplies()
            if not replies_before:
                self.discussion.getDiscussionFor(reply_to_doc)
            reply_to_doc.discussion_reply("%s's reply" % u, "text of '%s' reply" % u)
            replies_after = self.discussion.getDiscussionFor(reply_to_doc).getReplies()
            disparity = len(replies_after) - len(replies_before)
            if not disparity:
                failed_users.append(u)
        self.assert_(not failed_users , "%s - member(s) CAN'T really ADD comment in terned off comments Moderation mode." % failed_users)


    def testAddCommentToReplyIllegalUsers(self):
        # This users CAN'T ADD COMMENTS
        # This is actual only in terned OFF *Anonymous commenting mode*
        for u in self.illegal_users:
            self.login('admin')
            if u=='anonym':
                self.logout()
            else:
                self.logout()
                self.login(u)
            doc_obj = getattr(self.portal, self.doc_moder_off_id)
            # Get reply to this document
            reply_to_doc = self.discussion.getDiscussionFor(doc_obj).getReplies()[0]
            # Create talkback for reply and Add comment
            self.discussion.getDiscussionFor(reply_to_doc)
            self.assertRaises(Unauthorized, reply_to_doc.discussion_reply, "%s's reply" % u, "text of '%s' reply" % u)


class TestModerationAnonymComm(TestCommBase, TestMixinAnonymOn, TestMixinModerationOn):

    def afterSetUp(self):
        TestCommBase.afterSetUp(self)
        # Preparation for functional testing
        # Tern On Moderation and tern on Anonymous commenting 
        self.request.form['enable_anonymous_commenting'] = 'True'
        self.request.form['enable_moderation'] = 'True'
        self.portal.prefs_comments_setup()
        # Initialize base classes
        TestMixinAnonymOn.afterSetUp(self)
        TestMixinModerationOn.afterSetUp(self)


class TestModerationOFFAnonymComm(TestCommBase, TestMixinAnonymOff, TestMixinModerationOn):

    def afterSetUp(self):
        TestCommBase.afterSetUp(self)
        # Preparation for functional testing
        # Tern On Moderation and tern off Anonymous commenting 
        self.request.form['enable_moderation'] = 'True'
        self.portal.prefs_comments_setup()
        # Initialize base classes
        TestMixinAnonymOff.afterSetUp(self)
        TestMixinModerationOn.afterSetUp(self)



class TestAnonymCommOFFModeration(TestCommBase, TestMixinAnonymOn, TestMixinModerationOff):

    def afterSetUp(self):
        TestCommBase.afterSetUp(self)
        # Preparation for functional testing
        # Tern On Anonymous commenting and tern off  Moderation
        self.request.form['enable_anonymous_commenting'] = 'True'
        self.portal.prefs_comments_setup()
        # Initialize base classes
        TestMixinAnonymOn.afterSetUp(self)
        TestMixinModerationOff.afterSetUp(self)


class TestOFFModerationOFFAnonymComm(TestCommBase, TestMixinAnonymOff, TestMixinModerationOff):

    def afterSetUp(self):
        TestCommBase.afterSetUp(self)
        # Preparation for functional testing
        # Tern Off Moderation and tern off Anonymous commenting 
        self.portal.prefs_comments_setup()
        # Initialize base classes
        TestMixinAnonymOff.afterSetUp(self)
        TestMixinModerationOff.afterSetUp(self)

    

TESTS = [TestModerationAnonymComm, TestModerationOFFAnonymComm, TestAnonymCommOFFModeration, TestOFFModerationOFFAnonymComm]

def test_suite():
    from unittest import TestSuite, makeSuite
    suite = TestSuite()
    suite.addTest(makeSuite(TestModerationAnonymComm))
    suite.addTest(makeSuite(TestModerationOFFAnonymComm))
    suite.addTest(makeSuite(TestAnonymCommOFFModeration))
    suite.addTest(makeSuite(TestOFFModerationOFFAnonymComm))

    return suite

if __name__ == '__main__':
    framework()