plone.app.discussion/plone/app/discussion/tests/test_conversation.py

import unittest
from datetime import datetime, timedelta

from zope.component import createObject, queryUtility

from Acquisition import aq_base, aq_parent

from plone.app.vocabularies.types import BAD_TYPES

from plone.registry.interfaces import IRegistry

from Products.CMFCore.utils import getToolByName
from Products.PloneTestCase.ptc import PloneTestCase
from plone.app.discussion.tests.layer import DiscussionLayer

from plone.app.discussion.interfaces import IConversation, IComment, IReplies, IDiscussionSettings

class ConversationTest(PloneTestCase):

    layer = DiscussionLayer

    def afterSetUp(self):
        # First we need to create some content.
        self.loginAsPortalOwner()
        typetool = self.portal.portal_types
        typetool.constructContent('Document', self.portal, 'doc1')
        self.typetool = typetool
        self.portal_discussion = getToolByName(self.portal, 'portal_discussion', None)

    def test_add_comment(self):
        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        # Add a comment. Note: in real life, we always create comments via the factory
        # to allow different factories to be swapped in

        comment = createObject('plone.Comment')
        comment.title = 'Comment 1'
        comment.text = 'Comment text'

        new_id = conversation.addComment(comment)

        # Check that the conversation methods return the correct data
        self.assert_(isinstance(comment.comment_id, long))
        self.assert_(IComment.providedBy(conversation[new_id]))
        self.assertEquals(aq_base(conversation[new_id].__parent__), aq_base(conversation))
        self.assertEquals(new_id, comment.comment_id)
        self.assertEquals(len(list(conversation.getComments())), 1)
        self.assertEquals(sum(1 for w in conversation.getThreads()), 1)
        self.assertEquals(conversation.total_comments, 1)
        self.assert_(conversation.last_comment_date - datetime.now() < timedelta(seconds=1))

    def test_delete_comment(self):
        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        # Add a comment. Note: in real life, we always create comments via the factory
        # to allow different factories to be swapped in

        comment = createObject('plone.Comment')
        comment.title = 'Comment 1'
        comment.text = 'Comment text'

        new_id = conversation.addComment(comment)

        # make sure the comment has been added
        self.assertEquals(len(list(conversation.getComments())), 1)
        self.assertEquals(sum(1 for w in conversation.getThreads()), 1)
        self.assertEquals(conversation.total_comments, 1)

        # delete the comment we just created
        del conversation[new_id]

        # make sure there is no comment left in the conversation
        self.assertEquals(len(list(conversation.getComments())), 0)
        self.assertEquals(sum(1 for w in conversation.getThreads()), 0)
        self.assertEquals(conversation.total_comments, 0)

    def test_delete_recursive(self):
        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        IReplies(conversation)

        # Create a nested comment structure:
        #
        # Conversation
        # +- Comment 1
        #    +- Comment 1_1
        #    |  +- Comment 1_1_1
        #    +- Comment 1_2
        # +- Comment 2
        #    +- Comment 2_1

        # Create all comments
        comment1 = createObject('plone.Comment')
        comment1.title = 'Comment 1'
        comment1.text = 'Comment text'

        comment1_1 = createObject('plone.Comment')
        comment1_1.title = 'Re: Comment 1'
        comment1_1.text = 'Comment text'

        comment1_1_1 = createObject('plone.Comment')
        comment1_1_1.title = 'Re: Re: Comment 1'
        comment1_1_1.text = 'Comment text'

        comment1_2 = createObject('plone.Comment')
        comment1_2.title = 'Re: Comment 1 (2)'
        comment1_2.text = 'Comment text'

        comment2 = createObject('plone.Comment')
        comment2.title = 'Comment 2'
        comment2.text = 'Comment text'

        comment2_1 = createObject('plone.Comment')
        comment2_1.title = 'Re: Comment 2'
        comment2_1.text = 'Comment text'

        # Create the nested comment structure
        new_id_1 = conversation.addComment(comment1)
        new_id_2 = conversation.addComment(comment2)

        comment1_1.in_reply_to = new_id_1
        new_id_1_1 = conversation.addComment(comment1_1)

        comment1_1_1.in_reply_to = new_id_1_1
        conversation.addComment(comment1_1_1)

        comment1_2.in_reply_to = new_id_1
        conversation.addComment(comment1_2)

        comment2_1.in_reply_to = new_id_2
        new_id_2_1 = conversation.addComment(comment2_1)

        del conversation[new_id_1]

        self.assertEquals(
            [{'comment': comment2,     'depth': 0, 'id': new_id_2},
             {'comment': comment2_1,   'depth': 1, 'id': new_id_2_1},
            ], list(conversation.getThreads()))

    def test_delete_comment_when_content_object_is_deleted(self):
        # Make sure all comments of a content object are deleted when the object
        # itself is deleted.
        conversation = IConversation(self.portal.doc1)
        comment = createObject('plone.Comment')
        comment.title = 'Comment 1'
        comment.text = 'Comment text'
        conversation.addComment(comment)

        # Delete the content object
        self.portal.manage_delObjects(['doc1'])
        
        # Make sure the comment has been deleted as well
        self.assertEquals(len(list(conversation.getComments())), 0)
        self.assertEquals(sum(1 for w in conversation.getThreads()), 0)
        self.assertEquals(conversation.total_comments, 0) 

    def test_allow_discussion(self):
        # This is not a real test! It's only there to understand the
        # allow discussion attribute. Maybe we should remove this at
        # some point.

        # 1) allow_discussion attribute: Every content object in Plone
        # has a allow_discussion attribute. By default it is set to None.


        # Create a conversation.
        IConversation(self.portal.doc1)

        # By default, discussion is disabled for all content types
        portal_types = getToolByName(self.portal, 'portal_types')
        for type in list(portal_types):
            type_fti = getattr(portal_types, type)
            if type not in BAD_TYPES:
                if type != 'Discussion Item':
                    self.failIf(type_fti.allowDiscussion())

        # By default, allow_discussion on newly created content objects is
        # set to False
        portal_discussion = getToolByName(self.portal, 'portal_discussion')
        self.assertEquals(portal_discussion.isDiscussionAllowedFor(self.portal.doc1), False)
        self.assertEquals(self.portal.doc1.getTypeInfo().allowDiscussion(), False)

        # The allow discussion flag is None by default
        self.failIf(getattr(self.portal.doc1, 'allow_discussion', None))

        # But isDiscussionAllowedFor, also checks if discussion is allowed on the
        # content type. So we allow discussion on the Document content type and
        # check if the Document object allows discussion now.
        document_fti = getattr(portal_types, 'Document')
        document_fti.manage_changeProperties(allow_discussion = True)
        self.assertEquals(portal_discussion.isDiscussionAllowedFor(self.portal.doc1), True)
        self.assertEquals(self.portal.doc1.getTypeInfo().allowDiscussion(), True)

        # We can also override the allow_discussion locally
        self.portal_discussion.overrideDiscussionFor(self.portal.doc1, False)
        # Check if the Document discussion is disabled
        self.assertEquals(portal_discussion.isDiscussionAllowedFor(self.portal.doc1), False)
        # Check that the local allow_discussion flag is now explicitly set to False
        self.assertEquals(getattr(self.portal.doc1, 'allow_discussion', None), False)

        # Disallow discussion on the Document content type again
        document_fti.manage_changeProperties(allow_discussion = False)
        self.assertEquals(portal_discussion.isDiscussionAllowedFor(self.portal.doc1), False)
        self.assertEquals(self.portal.doc1.getTypeInfo().allowDiscussion(), False)

        # Now we override allow_discussion again (True) for the Document
        # content object
        self.portal_discussion.overrideDiscussionFor(self.portal.doc1, True)
        self.assertEquals(portal_discussion.isDiscussionAllowedFor(self.portal.doc1), True)
        self.assertEquals(getattr(self.portal.doc1, 'allow_discussion', None), True)

    def test_disable_commenting_globally(self):

        # Create a conversation.
        conversation = IConversation(self.portal.doc1)

        # We have to allow discussion on Document content type, since
        # otherwise allow_discussion will always return False
        portal_types = getToolByName(self.portal, 'portal_types')
        document_fti = getattr(portal_types, 'Document')
        document_fti.manage_changeProperties(allow_discussion = True)

        # Check if conversation is enabled now
        self.assertEquals(conversation.enabled(), True)

        # Disable commenting in the registry
        registry = queryUtility(IRegistry)
        settings = registry.forInterface(IDiscussionSettings)
        settings.globally_enabled = False

        # Check if commenting is disabled on the conversation
        self.assertEquals(conversation.enabled(), False)

        # Enable discussion again
        settings.globally_enabled = True
        self.assertEquals(conversation.enabled(), True)


    def test_allow_discussion_for_news_items(self):

        self.typetool.constructContent('News Item', self.portal, 'newsitem')
        newsitem = self.portal.newsitem
        conversation = IConversation(newsitem)

        # We have to allow discussion on Document content type, since
        # otherwise allow_discussion will always return False
        portal_types = getToolByName(self.portal, 'portal_types')
        document_fti = getattr(portal_types, 'News Item')
        document_fti.manage_changeProperties(allow_discussion = True)

        # Check if conversation is enabled now
        self.assertEquals(conversation.enabled(), True)

        # Disable commenting in the registry
        registry = queryUtility(IRegistry)
        settings = registry.forInterface(IDiscussionSettings)
        settings.globally_enabled = False

        # Check if commenting is disabled on the conversation
        self.assertEquals(conversation.enabled(), False)

        # Enable discussion again
        settings.globally_enabled = True
        self.assertEquals(conversation.enabled(), True)

    def test_disable_commenting_for_content_type(self):

        # Create a conversation.
        conversation = IConversation(self.portal.doc1)

        # The Document content type is disabled by default
        self.assertEquals(conversation.enabled(), False)

        # Allow discussion on Document content type
        portal_types = getToolByName(self.portal, 'portal_types')
        document_fti = getattr(portal_types, 'Document')
        document_fti.manage_changeProperties(allow_discussion = True)

        # Check if conversation is enabled now
        self.assertEquals(conversation.enabled(), True)

        # Disallow discussion on Document content type
        portal_types = getToolByName(self.portal, 'portal_types')
        document_fti = getattr(portal_types, 'Document')
        document_fti.manage_changeProperties(allow_discussion = False)

        # Check if conversation is enabled now
        self.assertEquals(conversation.enabled(), False)

    def test_allow_discussion_on_folder(self):
        # The enabled method should always return False for the folder
        # itself.

        # Create a folder
        self.typetool.constructContent('Folder', self.portal, 'f1')
        f1 = self.portal.f1
        # Usually we don't create a conversation on a folder
        conversation = IConversation(self.portal.f1)

        # Allow discussion for the folder
        self.portal_discussion.overrideDiscussionFor(f1, True)

        # Allow discussion on Folder content type
        portal_types = getToolByName(self.portal, 'portal_types')
        document_fti = getattr(portal_types, 'Folder')
        document_fti.manage_changeProperties(allow_discussion = True)

        # Always return False
        self.failIf(conversation.enabled())

    def test_is_discussion_allowed_for_folder(self):
        # When a content item provides IFolderish from CMF and
        # does not provide INonStructuralFolder from Plone,
        # allow_discussion acts as an on/off flag for all items
        # in that folder, overriding settings for any parent folders,
        # and the for the FTI, but is overridden by child items and
        # folders further down.

        # Create a folder
        self.typetool.constructContent('Folder', self.portal, 'f1')
        f1 = self.portal.f1

        # Create a document inside the folder
        self.typetool.constructContent('Document', f1, 'doc1')
        doc1 = self.portal.f1.doc1
        doc1_conversation = IConversation(doc1)

        self.assertEquals(doc1_conversation.enabled(), False)

        # Allow commenting for the folder
        self.portal_discussion.overrideDiscussionFor(f1, True)

        # Check if the content objects allows discussion
        self.assertEquals(doc1_conversation.enabled(), True)

        # Turn commenting for the folder off
        self.portal_discussion.overrideDiscussionFor(f1, False)

        # Check if content objects do not allow discussion anymore
        self.assertEquals(doc1_conversation.enabled(), False)

    def test_is_discussion_allowed_on_content_object(self):
        # Allow discussion on a single content object

        # Create a conversation.
        conversation = IConversation(self.portal.doc1)

        # Discussion is disallowed by default
        self.assertEquals(conversation.enabled(), False)

        # Allow discussion on content object
        self.portal_discussion.overrideDiscussionFor(self.portal.doc1, True)

        # Check if discussion is now allowed on the content object
        self.assertEquals(conversation.enabled(), True)

        self.portal_discussion.overrideDiscussionFor(self.portal.doc1, False)
        self.assertEquals(conversation.enabled(), False)

    def test_dict_operations(self):
        # test dict operations and acquisition wrapping

        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        # Add a comment. Note: in real life, we always create comments via the factory
        # to allow different factories to be swapped in

        comment1 = createObject('plone.Comment')
        comment1.title = 'Comment 1'
        comment1.text = 'Comment text'

        new_id1 = conversation.addComment(comment1)

        comment2 = createObject('plone.Comment')
        comment2.title = 'Comment 2'
        comment2.text = 'Comment text'

        new_id2 = conversation.addComment(comment2)

        # check if get returns a comment object, and None if the key
        # can not be found
        self.failUnless(IComment.providedBy(conversation.get(new_id1)))
        self.failUnless(IComment.providedBy(conversation.get(new_id2)))
        self.assertEquals(conversation.get(123), None)

        # check if keys return the ids of all comments
        self.assertEquals(len(conversation.keys()), 2)
        self.failUnless(new_id1 in conversation.keys())
        self.failUnless(new_id2 in conversation.keys())
        self.failIf(123 in conversation.keys())

        # check if items returns (key, comment object) pairs
        self.assertEquals(len(conversation.items()), 2)
        self.failUnless((new_id1, comment1) in conversation.items())
        self.failUnless((new_id2, comment2) in conversation.items())

        # check if values returns the two comment objects
        self.assertEquals(len(conversation.values()), 2)
        self.failUnless(comment1 in conversation.values())
        self.failUnless(comment2 in conversation.values())

        # check if comment ids are in iterkeys
        self.failUnless(new_id1 in conversation.iterkeys())
        self.failUnless(new_id2 in conversation.iterkeys())
        self.failIf(123 in conversation.iterkeys())

        # check if comment objects are in itervalues
        self.failUnless(comment1 in conversation.itervalues())
        self.failUnless(comment2 in conversation.itervalues())

        # check if iteritems returns (key, comment object) pairs
        self.failUnless((new_id1, comment1) in conversation.iteritems())
        self.failUnless((new_id2, comment2) in conversation.iteritems())

        # TODO test acquisition wrapping
        #self.failUnless(aq_base(aq_parent(comment1)) is conversation)

    def test_total_comments(self):
        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        # Add a three comments. Note: in real life, we always create
        # comments via the factory to allow different factories to be
        # swapped in

        comment1 = createObject('plone.Comment')
        comment1.title = 'Comment 1'
        comment1.text = 'Comment text'

        comment2 = createObject('plone.Comment')
        comment2.title = 'Comment 2'
        comment2.text = 'Comment text'

        comment3 = createObject('plone.Comment')
        comment3.title = 'Comment 3'
        comment3.text = 'Comment text'

        conversation.addComment(comment1)
        conversation.addComment(comment2)
        conversation.addComment(comment3)

        self.assertEquals(conversation.total_comments, 3)

    def test_commentators(self):
        # add and remove a few comments to make sure the commentators
        # property returns a true set

        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        self.assertEquals(conversation.total_comments, 0)

        # Add a four comments from three different users
        # Note: in real life, we always create
        # comments via the factory to allow different factories to be
        # swapped in
        comment1 = createObject('plone.Comment')
        comment1.title = 'Comment 1'
        comment1.text = 'Comment text'
        comment1.author_username = "Jim"
        conversation.addComment(comment1)

        comment2 = createObject('plone.Comment')
        comment2.title = 'Comment 2'
        comment2.text = 'Comment text'
        comment2.author_username = "Joe"
        conversation.addComment(comment2)

        comment3 = createObject('plone.Comment')
        comment3.title = 'Comment 3'
        comment3.text = 'Comment text'
        comment3.author_username = "Jack"
        new_comment3_id = conversation.addComment(comment3)

        comment4 = createObject('plone.Comment')
        comment4.title = 'Comment 3'
        comment4.text = 'Comment text'
        comment4.author_username = "Jack"
        new_comment4_id = conversation.addComment(comment4)

        # check if all commentators are in the commentators list
        self.assertEquals(conversation.total_comments, 4)
        self.failUnless('Jim' in conversation.commentators)
        self.failUnless('Joe' in conversation.commentators)
        self.failUnless('Jack' in conversation.commentators)

        # remove the comment from Jack
        del conversation[new_comment3_id]

        # check if Jack is still in the commentators list (since
        # he had added two comments)
        self.failUnless('Jim' in conversation.commentators)
        self.failUnless('Joe' in conversation.commentators)
        self.failUnless('Jack' in conversation.commentators)
        self.assertEquals(conversation.total_comments, 3)

        # remove the second comment from Jack
        del conversation[new_comment4_id]

        # check if Jack has been removed from the commentators list
        self.failUnless('Jim' in conversation.commentators)
        self.failUnless('Joe' in conversation.commentators)
        self.failIf('Jack' in conversation.commentators)
        self.assertEquals(conversation.total_comments, 2)

    def test_last_comment_date(self):
        # add and remove some comments and check if last_comment_date
        # is properly updated

        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        # Add a three comments that are at least one day old
        # Note: in real life, we always create
        # comments via the factory to allow different factories to be
        # swapped in
        comment1 = createObject('plone.Comment')
        comment1.title = 'Comment 1'
        comment1.text = 'Comment text'
        comment1.creation_date = datetime.now() - timedelta(4)
        conversation.addComment(comment1)

        comment2 = createObject('plone.Comment')
        comment2.title = 'Comment 2'
        comment2.text = 'Comment text'
        comment2.creation_date = datetime.now() - timedelta(2)
        new_comment2_id = conversation.addComment(comment2)

        comment3 = createObject('plone.Comment')
        comment3.title = 'Comment 3'
        comment3.text = 'Comment text'
        comment3.creation_date = datetime.now() - timedelta(1)
        new_comment3_id = conversation.addComment(comment3)

        # check if the latest comment is exactly one day old
        self.assert_(conversation.last_comment_date < datetime.now() - timedelta(hours=23, minutes=59, seconds=59))
        self.assert_(conversation.last_comment_date > datetime.now() - timedelta(days=1, seconds=1))

        # remove the latest comment
        del conversation[new_comment3_id]

        # check if the latest comment has been updated
        # the latest comment should be exactly two days old
        self.assert_(conversation.last_comment_date < datetime.now() - timedelta(days=1, hours=23, minutes=59, seconds=59))
        self.assert_(conversation.last_comment_date > datetime.now() - timedelta(days=2, seconds=1))

        # remove the latest comment again
        del conversation[new_comment2_id]

        # check if the latest comment has been updated
        # the latest comment should be exactly four days old
        self.assert_(conversation.last_comment_date < datetime.now() - timedelta(days=3, hours=23, minutes=59, seconds=59))
        self.assert_(conversation.last_comment_date > datetime.now() - timedelta(days=4, seconds=2))

    def test_get_comments_full(self):
        pass

    def test_get_comments_batched(self):
        pass

    def test_get_threads(self):

        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        IReplies(conversation)

        # Create a nested comment structure:
        #
        # Conversation
        # +- Comment 1
        #    +- Comment 1_1
        #    |  +- Comment 1_1_1
        #    +- Comment 1_2
        # +- Comment 2
        #    +- Comment 2_1

        # Create all comments
        comment1 = createObject('plone.Comment')
        comment1.title = 'Comment 1'
        comment1.text = 'Comment text'

        comment1_1 = createObject('plone.Comment')
        comment1_1.title = 'Re: Comment 1'
        comment1_1.text = 'Comment text'

        comment1_1_1 = createObject('plone.Comment')
        comment1_1_1.title = 'Re: Re: Comment 1'
        comment1_1_1.text = 'Comment text'

        comment1_2 = createObject('plone.Comment')
        comment1_2.title = 'Re: Comment 1 (2)'
        comment1_2.text = 'Comment text'

        comment2 = createObject('plone.Comment')
        comment2.title = 'Comment 2'
        comment2.text = 'Comment text'

        comment2_1 = createObject('plone.Comment')
        comment2_1.title = 'Re: Comment 2'
        comment2_1.text = 'Comment text'

        # Create the nested comment structure
        new_id_1 = conversation.addComment(comment1)
        new_id_2 = conversation.addComment(comment2)

        comment1_1.in_reply_to = new_id_1
        new_id_1_1 = conversation.addComment(comment1_1)

        comment1_1_1.in_reply_to = new_id_1_1
        new_id_1_1_1 = conversation.addComment(comment1_1_1)

        comment1_2.in_reply_to = new_id_1
        new_id_1_2 = conversation.addComment(comment1_2)

        comment2_1.in_reply_to = new_id_2
        new_id_2_1 = conversation.addComment(comment2_1)

        # Get threads

        self.assertEquals(
            [{'comment': comment1,     'depth': 0, 'id': new_id_1},
             {'comment': comment1_1,   'depth': 1, 'id': new_id_1_1},
             {'comment': comment1_1_1, 'depth': 2, 'id': new_id_1_1_1},
             {'comment': comment1_2,   'depth': 1, 'id': new_id_1_2},
             {'comment': comment2,     'depth': 0, 'id': new_id_2},
             {'comment': comment2_1,   'depth': 1, 'id': new_id_2_1},
            ], list(conversation.getThreads()))

    def test_get_threads_batched(self):
        # TODO: test start, size, root and depth arguments to getThreads()
        #   - may want to split this into multiple tests
        pass

    def test_traversal(self):
        # make sure we can traverse to conversations and get a URL and path

        conversation = self.portal.doc1.restrictedTraverse('++conversation++default')
        self.assert_(IConversation.providedBy(conversation))

        self.assertEquals(('', 'plone', 'doc1', '++conversation++default'), conversation.getPhysicalPath())
        # XXX: conversation.absolute_url() returns different values dependent on
        # the Plone version used.
        # Plone 3.3:
        #self.assertEquals('plone/doc1/%2B%2Bconversation%2B%2Bdefault', conversation.absolute_url())
        # Plone 4:
        #self.assertEquals('http://nohost/plone/doc1/++conversation++default', conversation.absolute_url())

    def test_parent(self):
        # Check that conversation has a content object as parent

        # Create a conversation.
        conversation = IConversation(self.portal.doc1)

        # Check the parent
        self.failUnless(conversation.__parent__)
        self.failUnless(aq_parent(conversation))

        self.assertEquals(conversation.__parent__.getId(), 'doc1')


    def test_discussion_item_not_in_bad_types(self):
        self.failIf('Discussion Item' in BAD_TYPES)


class RepliesTest(PloneTestCase):

    # test the IReplies adapter on a conversation

    layer = DiscussionLayer

    def afterSetUp(self):
        # First we need to create some content.
        self.loginAsPortalOwner()
        typetool = self.portal.portal_types
        typetool.constructContent('Document', self.portal, 'doc1')

    def test_add_comment(self):
        # Add comments to a ConversationReplies adapter

        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        replies = IReplies(conversation)

        comment = createObject('plone.Comment')
        comment.title = 'Comment 1'
        comment.text = 'Comment text'

        new_id = replies.addComment(comment)

        # check that replies provides the IReplies interface
        self.assert_(IReplies.providedBy(replies))

        # Make sure our comment was added
        self.failUnless(new_id in replies)

        # Make sure it is also reflected in the conversation
        self.failUnless(new_id in conversation)

        self.assertEquals(conversation[new_id].comment_id, new_id)

    def test_delete_comment(self):
        # Create and remove a comment and check if the replies adapter
        # has been updated accordingly

        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        replies = IReplies(conversation)

        # Add a comment.
        comment = createObject('plone.Comment')
        comment.title = 'Comment 1'
        comment.text = 'Comment text'

        new_id = replies.addComment(comment)

        # make sure the comment has been added
        self.assertEquals(len(replies), 1)

        # delete the comment we just created
        del replies[new_id]

        # make sure there is no comment left in the conversation
        self.assertEquals(len(replies), 0)

    def test_dict_api(self):
        # This test is for the ConversationReplies as well as the
        # CommentReplies adapter.
        #
        # Ensure all operations use only top-level comments. Add some
        # deeper children and ensure that these are not exposed through the
        # IReplies dict.

        # Create a conversation. In this case we doesn't assign it to an
        # object, as we just want to check the Conversation object API.
        conversation = IConversation(self.portal.doc1)

        replies = IReplies(conversation)

        # Create a nested comment structure:
        #
        # Conversation
        # +- Comment 1
        #    +- Comment 1_1
        #    |  +- Comment 1_1_1
        #    +- Comment 1_2
        # +- Comment 2
        #    +- Comment 2_1

        # Create all comments
        comment1 = createObject('plone.Comment')
        comment1.title = 'Comment 1'
        comment1.text = 'Comment text'

        comment1_1 = createObject('plone.Comment')
        comment1_1.title = 'Re: Comment 1'
        comment1_1.text = 'Comment text'

        comment1_1_1 = createObject('plone.Comment')
        comment1_1_1.title = 'Re: Re: Comment 1'
        comment1_1_1.text = 'Comment text'

        comment1_2 = createObject('plone.Comment')
        comment1_2.title = 'Re: Comment 1 (2)'
        comment1_2.text = 'Comment text'

        comment2 = createObject('plone.Comment')
        comment2.title = 'Comment 2'
        comment2.text = 'Comment text'

        comment2_1 = createObject('plone.Comment')
        comment2_1.title = 'Re: Comment 2'
        comment2_1.text = 'Comment text'

        # Create the nested comment structure
        new_id_1 = replies.addComment(comment1)
        comment1 = self.portal.doc1.restrictedTraverse('++conversation++default/%s' % new_id_1)
        replies_to_comment1 = IReplies(comment1)
        new_id_2 = replies.addComment(comment2)
        comment2 = self.portal.doc1.restrictedTraverse('++conversation++default/%s' % new_id_2)
        replies_to_comment2 = IReplies(comment2)

        new_id_1_1 = replies_to_comment1.addComment(comment1_1)
        comment1_1 = self.portal.doc1.restrictedTraverse('++conversation++default/%s' % new_id_1_1)
        replies_to_comment1_1 = IReplies(comment1_1)
        replies_to_comment1_1.addComment(comment1_1_1)

        replies_to_comment1.addComment(comment1_2)

        replies_to_comment2.addComment(comment2_1)

        # check that replies only contain the direct comments
        # and no comments deeper than 1
        self.assertEquals(conversation.total_comments, 6)
        self.assertEquals(len(replies), 2)
        self.assertEquals(len(replies_to_comment1), 2)
        self.assertEquals(len(replies_to_comment1_1), 1)
        self.assertEquals(len(replies_to_comment2), 1)

def test_suite():
    return unittest.defaultTestLoader.loadTestsFromName(__name__)