ajung/plone.app.discussion
ajung/plone.app.discussion
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Avoid using deprecated test assertions, see http://docs.python.org/dev/library/unittest.html#deprecated-aliases for the full list

Browse Source 
svn path=/plone.app.discussion/trunk/; revision=48881
This commit is contained in:
Hanno Schlichting 2011-04-15 16:23:38 +00:00
parent 811d4a0429
commit 9db8909ea7
12 changed files with 372 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
plone/app/discussion/tests/qunit/QUnitAdapter.js
View File

@ -54,7 +54,7 @@ you need to set it up and tear it down in each test.
};
window.equals = function(a, b, msg) {
assertEquals(msg ? msg : '', b, a);
assertEqual(msg ? msg : '', b, a);
};
window.start = window.stop = function() {

84
plone/app/discussion/tests/test_catalog.py
View File

@ -21,13 +21,13 @@ class CatalogSetupTest(PloneTestCase):
layer = DiscussionLayer
def test_catalog_installed(self):
self.failUnless('total_comments' in
self.assertTrue('total_comments' in
self.portal.portal_catalog.indexes())
self.failUnless('commentators' in
self.assertTrue('commentators' in
self.portal.portal_catalog.indexes())
self.failUnless('total_comments' in
self.assertTrue('total_comments' in
self.portal.portal_catalog.schema())
self.failUnless('in_response_to' in
self.assertTrue('in_response_to' in
self.portal.portal_catalog.schema())
def test_collection_criteria_installed(self):
@ -77,8 +77,8 @@ class ConversationCatalogTest(PloneTestCase):
self.new_comment1_id = new_comment1_id
def test_total_comments(self):
self.failUnless('total_comments' in self.doc1_brain)
self.assertEquals(self.doc1_brain.total_comments, 1)
self.assertTrue('total_comments' in self.doc1_brain)
self.assertEqual(self.doc1_brain.total_comments, 1)
comment2 = createObject('plone.Comment')
comment2.title = 'Comment 2'
@ -95,11 +95,11 @@ class ConversationCatalogTest(PloneTestCase):
portal_type="Document"
))
doc1_brain = brains[0]
self.assertEquals(doc1_brain.total_comments, 2)
self.assertEqual(doc1_brain.total_comments, 2)
def test_last_comment_date(self):
self.failUnless('last_comment_date' in self.doc1_brain)
self.assertEquals(self.doc1_brain.last_comment_date,
self.assertTrue('last_comment_date' in self.doc1_brain)
self.assertEqual(self.doc1_brain.last_comment_date,
datetime(2006, 9, 17, 14, 18, 12))
# Add another comment and check if last comment date is updated.
@ -120,7 +120,7 @@ class ConversationCatalogTest(PloneTestCase):
portal_type="Document"
))
doc1_brain = brains[0]
self.assertEquals(doc1_brain.last_comment_date,
self.assertEqual(doc1_brain.last_comment_date,
datetime(2009, 9, 17, 14, 18, 12))
# Remove the comment again
@ -133,7 +133,7 @@ class ConversationCatalogTest(PloneTestCase):
))
doc1_brain = brains[0]
self.assertEquals(doc1_brain.last_comment_date,
self.assertEqual(doc1_brain.last_comment_date,
datetime(2006, 9, 17, 14, 18, 12))
# remove all comments
@ -144,11 +144,11 @@ class ConversationCatalogTest(PloneTestCase):
portal_type="Document"
))
doc1_brain = brains[0]
self.assertEquals(doc1_brain.last_comment_date, None)
self.assertEqual(doc1_brain.last_comment_date, None)
def test_commentators(self):
self.failUnless('commentators' in self.doc1_brain)
self.assertEquals(self.doc1_brain.commentators, ('Jim',))
self.assertTrue('commentators' in self.doc1_brain)
self.assertEqual(self.doc1_brain.commentators, ('Jim',))
# add another comment with another author
comment2 = createObject('plone.Comment')
@ -169,7 +169,7 @@ class ConversationCatalogTest(PloneTestCase):
))
doc1_brain = brains[0]
self.assertEquals(doc1_brain.commentators, ('Emma', 'Jim'))
self.assertEqual(doc1_brain.commentators, ('Emma', 'Jim'))
# remove one comments
del self.conversation[new_comment2_id]
@ -179,7 +179,7 @@ class ConversationCatalogTest(PloneTestCase):
portal_type="Document"
))
doc1_brain = brains[0]
self.assertEquals(doc1_brain.commentators, ('Jim',))
self.assertEqual(doc1_brain.commentators, ('Jim',))
# remove all comments
del self.conversation[self.new_comment1_id]
@ -189,7 +189,7 @@ class ConversationCatalogTest(PloneTestCase):
portal_type="Document"
))
doc1_brain = brains[0]
self.assertEquals(doc1_brain.commentators, ())
self.assertEqual(doc1_brain.commentators, ())
def test_conversation_indexes_not_in_comments(self):
brains = self.catalog.searchResults(dict(
@ -198,9 +198,9 @@ class ConversationCatalogTest(PloneTestCase):
portal_type="Discussion Item"
))
comment1_brain = brains[0]
self.assertEquals(comment1_brain.commentators, None)
self.assertEquals(comment1_brain.last_comment_date, None)
self.assertEquals(comment1_brain.total_comments, None)
self.assertEqual(comment1_brain.commentators, None)
self.assertEqual(comment1_brain.last_comment_date, None)
self.assertEqual(comment1_brain.total_comments, None)
class CommentCatalogTest(PloneTestCase):
@ -234,7 +234,7 @@ class CommentCatalogTest(PloneTestCase):
self.comment_brain = brains[0]
def test_title(self):
self.assertEquals(self.comment_brain.Title, 'Jim on Document 1')
self.assertEqual(self.comment_brain.Title, 'Jim on Document 1')
def test_no_name_title(self):
comment = createObject('plone.Comment')
@ -248,27 +248,27 @@ class CommentCatalogTest(PloneTestCase):
path={'query':
'/'.join(comment.getPhysicalPath())}))
comment_brain = brains[0]
self.assertEquals(comment_brain.Title, "Anonymous on Document 1")
self.assertEqual(comment_brain.Title, "Anonymous on Document 1")
def test_type(self):
self.assertEquals(self.comment_brain.portal_type, 'Discussion Item')
self.assertEquals(self.comment_brain.meta_type, 'Discussion Item')
self.assertEquals(self.comment_brain.Type, 'Comment')
self.assertEqual(self.comment_brain.portal_type, 'Discussion Item')
self.assertEqual(self.comment_brain.meta_type, 'Discussion Item')
self.assertEqual(self.comment_brain.Type, 'Comment')
def test_review_state(self):
self.assertEquals(self.comment_brain.review_state, 'published')
self.assertEqual(self.comment_brain.review_state, 'published')
def test_creator(self):
self.assertEquals(self.comment_brain.Creator, 'Jim')
self.assertEqual(self.comment_brain.Creator, 'Jim')
def test_in_response_to(self):
"""Make sure in_response_to returns the title or id of the content
object the comment was added to.
"""
self.assertEquals(self.comment_brain.in_response_to, 'Document 1')
self.assertEqual(self.comment_brain.in_response_to, 'Document 1')
def test_add_comment(self):
self.failUnless(self.comment_brain)
self.assertTrue(self.comment_brain)
def test_delete_comment(self):
# Make sure a comment is removed from the catalog as well when it is
@ -277,17 +277,17 @@ class CommentCatalogTest(PloneTestCase):
brains = self.catalog.searchResults(dict(
path={'query':
'/'.join(self.comment.getPhysicalPath())}))
self.assertEquals(len(brains), 0)
self.assertEqual(len(brains), 0)
def test_remove_comments_when_content_object_is_removed(self):
"""Make sure all comments are removed from the catalog, if the content
object is removed.
"""
brains = self.catalog.searchResults({'portal_type': 'Discussion Item'})
self.assertEquals(len(brains), 1)
self.assertEqual(len(brains), 1)
self.portal.manage_delObjects(["doc1"])
brains = self.catalog.searchResults({'portal_type': 'Discussion Item'})
self.assertEquals(len(brains), 0)
self.assertEqual(len(brains), 0)
def test_clear_and_rebuild_catalog(self):
# Clear and rebuild catalog
@ -295,9 +295,9 @@ class CommentCatalogTest(PloneTestCase):
# Check if comment is still there
brains = self.catalog.searchResults({'portal_type': 'Discussion Item'})
self.failUnless(brains)
self.assertTrue(brains)
comment_brain = brains[0]
self.assertEquals(comment_brain.Title, u'Jim on Document 1')
self.assertEqual(comment_brain.Title, u'Jim on Document 1')
def test_clear_and_rebuild_catalog_for_nested_comments(self):
@ -352,8 +352,8 @@ class CommentCatalogTest(PloneTestCase):
# Check if comments are still there
brains = self.catalog.searchResults({'portal_type': 'Discussion Item'})
self.failUnless(brains)
self.assertEquals(len(brains), 6)
self.assertTrue(brains)
self.assertEqual(len(brains), 6)
def test_collection(self):
self.portal.invokeFactory(id='topic', type_name='Topic')
@ -363,9 +363,9 @@ class CommentCatalogTest(PloneTestCase):
query = topic.buildQuery()
# Make sure the comment we just added is returned by the collection
self.assertEquals(len(query), 1)
self.assertEquals(query['Type'], 'Comment')
self.assertEquals(len(topic.queryCatalog()), 1)
self.assertEqual(len(query), 1)
self.assertEqual(query['Type'], 'Comment')
self.assertEqual(len(topic.queryCatalog()), 1)
class NoConversationCatalogTest(PloneTestCase):
@ -393,11 +393,11 @@ class NoConversationCatalogTest(PloneTestCase):
self.doc1_brain = brains[0]
def test_total_comments(self):
self.failUnless('total_comments' in self.doc1_brain)
self.assertEquals(self.doc1_brain.total_comments, 0)
self.assertTrue('total_comments' in self.doc1_brain)
self.assertEqual(self.doc1_brain.total_comments, 0)
# Make sure no conversation has been created
self.assert_('plone.app.discussion:conversation' not in
self.assertTrue('plone.app.discussion:conversation' not in
IAnnotations(self.portal.doc1))

86
plone/app/discussion/tests/test_comment.py
View File

@ -40,7 +40,7 @@ class CommentTest(PloneTestCase):
def test_factory(self):
comment1 = createObject('plone.Comment')
self.assert_(IComment.providedBy(comment1))
self.assertTrue(IComment.providedBy(comment1))
def test_UTCDates(self):
utc_to_local_diff = datetime.datetime.now() - datetime.datetime.utcnow()
@ -61,9 +61,9 @@ class CommentTest(PloneTestCase):
def test_id(self):
comment1 = createObject('plone.Comment')
comment1.comment_id = 123
self.assertEquals('123', comment1.id)
self.assertEquals('123', comment1.getId())
self.assertEquals(u'123', comment1.__name__)
self.assertEqual('123', comment1.id)
self.assertEqual('123', comment1.getId())
self.assertEqual(u'123', comment1.__name__)
def test_uid(self):
conversation = IConversation(self.portal.doc1)
@ -71,7 +71,7 @@ class CommentTest(PloneTestCase):
conversation.addComment(comment1)
comment_brain = self.catalog.searchResults(
portal_type = 'Discussion Item')[0]
self.failUnless(comment_brain.UID)
self.assertTrue(comment_brain.UID)
def test_uid_is_unique(self):
conversation = IConversation(self.portal.doc1)
@ -81,7 +81,7 @@ class CommentTest(PloneTestCase):
conversation.addComment(comment2)
brains = self.catalog.searchResults(
portal_type = 'Discussion Item')
self.assertNotEquals(brains[0].UID, brains[1].UID)
self.assertNotEqual(brains[0].UID, brains[1].UID)
def test_comment_uid_differs_from_content_uid(self):
conversation = IConversation(self.portal.doc1)
@ -89,20 +89,20 @@ class CommentTest(PloneTestCase):
conversation.addComment(comment1)
comment_brain = self.catalog.searchResults(
portal_type = 'Discussion Item')[0]
self.assertNotEquals(self.document_brain.UID, comment_brain.UID)
self.assertNotEqual(self.document_brain.UID, comment_brain.UID)
def test_title(self):
conversation = IConversation(self.portal.doc1)
comment1 = createObject('plone.Comment')
comment1.creator = "Jim Fulton"
conversation.addComment(comment1)
self.assertEquals("Jim Fulton on Document 1", comment1.Title())
self.assertEqual("Jim Fulton on Document 1", comment1.Title())
def test_no_name_title(self):
conversation = IConversation(self.portal.doc1)
comment1 = createObject('plone.Comment')
conversation.addComment(comment1)
self.assertEquals("Anonymous on Document 1", comment1.Title())
self.assertEqual("Anonymous on Document 1", comment1.Title())
def test_title_special_characters(self):
self.portal.invokeFactory(id='doc_sp_chars',
@ -112,54 +112,54 @@ class CommentTest(PloneTestCase):
comment1 = createObject('plone.Comment')
comment1.creator = u"Tarek Ziadé"
conversation.addComment(comment1)
self.assertEquals(u"Tarek Ziadé on Document äüö", comment1.Title())
self.assertEqual(u"Tarek Ziadé on Document äüö", comment1.Title())
def test_creator(self):
comment1 = createObject('plone.Comment')
comment1.creator = "Jim"
self.assertEquals("Jim", comment1.Creator())
self.assertEqual("Jim", comment1.Creator())
def test_type(self):
comment1 = createObject('plone.Comment')
self.assertEquals(comment1.Type(), 'Comment')
self.assertEqual(comment1.Type(), 'Comment')
def test_getText(self):
comment1 = createObject('plone.Comment')
comment1.text = """First paragraph
Second paragraph"""
self.assertEquals(comment1.getText(),
self.assertEqual(comment1.getText(),
"<p>First paragraph<br /><br /> Second paragraph</p>")
def test_getText_escapes_HTML(self):
comment1 = createObject('plone.Comment')
comment1.text = """<b>Got HTML?</b>"""
self.assertEquals(comment1.getText(),
self.assertEqual(comment1.getText(),
"<p>&lt;b&gt;Got HTML?&lt;/b&gt;</p>")
def test_getText_with_non_ascii_characters(self):
comment1 = createObject('plone.Comment')
comment1.text = u"""Umlaute sind ä, ö und ü."""
self.assertEquals(comment1.getText(),
self.assertEqual(comment1.getText(),
'<p>Umlaute sind \xc3\xa4, \xc3\xb6 und \xc3\xbc.</p>')
def test_getText_doesnt_link(self):
comment1 = createObject('plone.Comment')
comment1.text = "Go to http://www.plone.org"
self.assertEquals(comment1.getText(),
self.assertEqual(comment1.getText(),
"<p>Go to http://www.plone.org</p>")
def test_getText_uses_comment_mime_type(self):
comment1 = createObject('plone.Comment')
comment1.text = "Go to http://www.plone.org"
comment1.mime_type = 'text/x-web-intelligent'
self.assertEquals(comment1.getText(),
self.assertEqual(comment1.getText(),
'Go to <a href="http://www.plone.org" rel="nofollow">http://www.plone.org</a>')
def test_getText_w_custom_targetMimetype(self):
comment1 = createObject('plone.Comment')
comment1.text = 'para'
self.assertEquals(comment1.getText(targetMimetype='text/plain'), 'para')
self.assertEqual(comment1.getText(targetMimetype='text/plain'), 'para')
def test_traversal(self):
# make sure comments are traversable, have an id, absolute_url and
@ -174,11 +174,11 @@ class CommentTest(PloneTestCase):
comment = self.portal.doc1.restrictedTraverse(
'++conversation++default/%s' % new_comment1_id)
self.assert_(IComment.providedBy(comment))
self.assertTrue(IComment.providedBy(comment))
self.assertEquals(('', 'plone', 'doc1', '++conversation++default',
self.assertEqual(('', 'plone', 'doc1', '++conversation++default',
str(new_comment1_id)), comment.getPhysicalPath())
self.assertEquals('http://nohost/plone/doc1/++conversation++default/' +
self.assertEqual('http://nohost/plone/doc1/++conversation++default/' +
str(new_comment1_id), comment.absolute_url())
def test_workflow(self):
@ -196,26 +196,26 @@ class CommentTest(PloneTestCase):
# Make sure comments use the 'comment_review_workflow'
chain = self.portal.portal_workflow.getChainFor(comment)
self.assertEquals(('comment_review_workflow',), chain)
self.assertEqual(('comment_review_workflow',), chain)
# Ensure the initial state was entered and recorded
self.assertEquals(1,
self.assertEqual(1,
len(comment.workflow_history['comment_review_workflow']))
self.assertEquals(None,
self.assertEqual(None,
comment.workflow_history['comment_review_workflow'][0]\
['action'])
self.assertEquals('pending',
self.assertEqual('pending',
self.portal.portal_workflow.getInfoFor(comment, 'review_state'))
def test_fti(self):
# test that we can look up an FTI for Discussion Item
self.assert_("Discussion Item" in self.portal.portal_types.objectIds())
self.assertTrue("Discussion Item" in self.portal.portal_types.objectIds())
comment1 = createObject('plone.Comment')
fti = self.portal.portal_types.getTypeInfo(comment1)
self.assertEquals('Discussion Item', fti.getTypeInfo(comment1).getId())
self.assertEqual('Discussion Item', fti.getTypeInfo(comment1).getId())
def test_view(self):
# make sure that the comment view is there and redirects to the right
@ -236,14 +236,14 @@ class CommentTest(PloneTestCase):
'++conversation++default/%s' % new_comment1_id)
# make sure the view is there
self.failUnless(getMultiAdapter((comment, self.app.REQUEST),
self.assertTrue(getMultiAdapter((comment, self.app.REQUEST),
name='view'))
# make sure the HTTP redirect (status code 302) works when a comment
# is called directly
view = View(comment, self.app.REQUEST)
View.__call__(view)
self.assertEquals(self.app.REQUEST.response.status, 302)
self.assertEqual(self.app.REQUEST.response.status, 302)
class RepliesTest(PloneTestCase):
@ -284,16 +284,16 @@ class RepliesTest(PloneTestCase):
new_re_id = replies.addComment(re_comment)
# check that replies provides the IReplies interface
self.assert_(IReplies.providedBy(replies))
self.assertTrue(IReplies.providedBy(replies))
# Make sure our comment was added
self.failUnless(new_re_id in replies)
self.assertTrue(new_re_id in replies)
# Make sure it is also reflected in the conversation
self.failUnless(new_re_id in conversation)
self.assertTrue(new_re_id in conversation)
# Make sure the conversation has the correct comment id
self.assertEquals(conversation[new_re_id].comment_id, new_re_id)
self.assertEqual(conversation[new_re_id].comment_id, new_re_id)
def test_delete_comment(self):
# Add and remove a comment to a CommentReplies adapter
@ -323,10 +323,10 @@ class RepliesTest(PloneTestCase):
del replies[new_re_id]
# Make sure there is no comment left in CommentReplies
self.assertEquals(len(replies), 0)
self.assertEqual(len(replies), 0)
# Make sure the first comment is still in the conversation
self.assertEquals(conversation.total_comments, 1)
self.assertEqual(conversation.total_comments, 1)
def test_traversal(self):
# Create a nested structure of comment replies and check the traversal
@ -370,22 +370,22 @@ class RepliesTest(PloneTestCase):
re_re_re_comment = self.portal.doc1.restrictedTraverse(
'++conversation++default/%s' % new_re_re_re_id)
self.assertEquals(('', 'plone', 'doc1', '++conversation++default',
self.assertEqual(('', 'plone', 'doc1', '++conversation++default',
str(new_id)), comment.getPhysicalPath())
self.assertEquals('http://nohost/plone/doc1/++conversation++default/' +
self.assertEqual('http://nohost/plone/doc1/++conversation++default/' +
str(new_id), comment.absolute_url())
self.assertEquals(('', 'plone', 'doc1', '++conversation++default',
self.assertEqual(('', 'plone', 'doc1', '++conversation++default',
str(new_re_id)), re_comment.getPhysicalPath())
self.assertEquals('http://nohost/plone/doc1/++conversation++default/' +
self.assertEqual('http://nohost/plone/doc1/++conversation++default/' +
str(new_re_id), re_comment.absolute_url())
self.assertEquals(('', 'plone', 'doc1', '++conversation++default',
self.assertEqual(('', 'plone', 'doc1', '++conversation++default',
str(new_re_re_id)), re_re_comment.getPhysicalPath())
self.assertEquals('http://nohost/plone/doc1/++conversation++default/' +
self.assertEqual('http://nohost/plone/doc1/++conversation++default/' +
str(new_re_re_id), re_re_comment.absolute_url())
self.assertEquals(('', 'plone', 'doc1', '++conversation++default',
self.assertEqual(('', 'plone', 'doc1', '++conversation++default',
str(new_re_re_re_id)),
re_re_re_comment.getPhysicalPath())
self.assertEquals('http://nohost/plone/doc1/++conversation++default/' +
self.assertEqual('http://nohost/plone/doc1/++conversation++default/' +
str(new_re_re_re_id),
re_re_re_comment.absolute_url())

88
plone/app/discussion/tests/test_comments_viewlet.py
View File

@ -89,8 +89,8 @@ class TestCommentForm(PloneTestCase):
commentForm.update()
data, errors = commentForm.extractData() # pylint: disable-msg=W0612
self.assertEquals(len(errors), 1)
self.failIf(commentForm.handleComment(commentForm, "foo"))
self.assertEqual(len(errors), 1)
self.assertFalse(commentForm.handleComment(commentForm, "foo"))
# The form is submitted successfully, if the required text field is
# filled out
@ -101,8 +101,8 @@ class TestCommentForm(PloneTestCase):
commentForm.update()
data, errors = commentForm.extractData() # pylint: disable-msg=W0612
self.assertEquals(len(errors), 0)
self.failIf(commentForm.handleComment(commentForm, "foo"))
self.assertEqual(len(errors), 0)
self.assertFalse(commentForm.handleComment(commentForm, "foo"))
def test_add_anonymous_comment(self):
"""Add a comment as anonymous.
@ -142,8 +142,8 @@ class TestCommentForm(PloneTestCase):
commentForm.update()
data, errors = commentForm.extractData() # pylint: disable-msg=W0612
self.assertEquals(len(errors), 0)
self.failIf(commentForm.handleComment(commentForm, "action"))
self.assertEqual(len(errors), 0)
self.assertFalse(commentForm.handleComment(commentForm, "action"))
def test_can_not_add_comments_if_discussion_is_not_allowed(self):
"""Make sure that comments can't be posted if discussion is disabled.
@ -172,7 +172,7 @@ class TestCommentForm(PloneTestCase):
# No form errors, but raise unauthorized because discussion is not
# allowed
self.assertEquals(len(errors), 0)
self.assertEqual(len(errors), 0)
self.assertRaises(Unauthorized,
commentForm.handleComment,
commentForm,
@ -206,7 +206,7 @@ class TestCommentForm(PloneTestCase):
commentForm.update()
data, errors = commentForm.extractData() # pylint: disable-msg=W0612
self.assertEquals(len(errors), 0)
self.assertEqual(len(errors), 0)
self.assertRaises(Unauthorized,
commentForm.handleComment,
commentForm,
@ -240,21 +240,21 @@ class TestCommentsViewlet(PloneTestCase):
def test_can_reply(self):
# Portal owner can reply
self.failUnless(self.viewlet.can_reply())
self.assertTrue(self.viewlet.can_reply())
self.logout()
# Anonymous users can not reply
self.failIf(self.viewlet.can_reply())
self.assertFalse(self.viewlet.can_reply())
def test_can_review(self):
# Portal owner has 'can review' permission
self.failUnless(self.viewlet.can_review())
self.assertTrue(self.viewlet.can_review())
self.logout()
# Anonymous has no 'can review' permission
self.failIf(self.viewlet.can_review())
self.assertFalse(self.viewlet.can_review())
# The reviewer role has the 'Review comments' permission
self.portal.acl_users._doAddUser('reviewer', 'secret', ['Reviewer'], [])
self.login('reviewer')
self.failUnless(self.viewlet.can_review())
self.assertTrue(self.viewlet.can_review())
def test_can_manage(self):
"""We keep this method for backward compatibility. This method has been
@ -262,29 +262,29 @@ class TestCommentsViewlet(PloneTestCase):
do API changes in beta releases.
"""
# Portal owner has 'can review' permission
self.failUnless(self.viewlet.can_manage())
self.assertTrue(self.viewlet.can_manage())
self.logout()
# Anonymous has no 'can review' permission
self.failIf(self.viewlet.can_manage())
self.assertFalse(self.viewlet.can_manage())
# The reviewer role has the 'Review comments' permission
self.portal.acl_users._doAddUser('reviewer', 'secret', ['Reviewer'], [])
self.login('reviewer')
self.failUnless(self.viewlet.can_manage())
self.assertTrue(self.viewlet.can_manage())
def test_is_discussion_allowed(self):
# By default, discussion is disabled
self.failIf(self.viewlet.is_discussion_allowed())
self.assertFalse(self.viewlet.is_discussion_allowed())
# Enable discussion
portal_discussion = getToolByName(self.portal, 'portal_discussion')
portal_discussion.overrideDiscussionFor(self.portal.doc1, True)
# Test if discussion has been enabled
self.failUnless(self.viewlet.is_discussion_allowed())
self.assertTrue(self.viewlet.is_discussion_allowed())
def test_comment_transform_message(self):
# Default transform is plain/text and comment moderation disabled
self.failUnless(self.viewlet.comment_transform_message())
self.assertEquals(
self.assertTrue(self.viewlet.comment_transform_message())
self.assertEqual(
self.viewlet.comment_transform_message(),
"You can add a comment by filling out the form below. Plain text " +
"formatting.")
@ -295,7 +295,7 @@ class TestCommentsViewlet(PloneTestCase):
settings.text_transform = "text/x-web-intelligent"
# Make sure the comment description changes accordingly
self.assertEquals(
self.assertEqual(
self.viewlet.comment_transform_message(),
"You can add a comment by filling out the form below. " +
"Plain text formatting. Web and email addresses are transformed " +
@ -307,41 +307,41 @@ class TestCommentsViewlet(PloneTestCase):
('comment_review_workflow,'))
# Make sure the comment description shows that comments are moderated
self.assertEquals(
self.assertEqual(
self.viewlet.comment_transform_message(),
"You can add a comment by filling out the form below. " +
"Plain text formatting. Web and email addresses are transformed " +
"into clickable links. Comments are moderated.")
def test_has_replies(self):
self.assertEquals(self.viewlet.has_replies(), False)
self.assertEqual(self.viewlet.has_replies(), False)
comment = createObject('plone.Comment')
comment.text = 'Comment text'
conversation = IConversation(self.portal.doc1)
conversation.addComment(comment)
self.assertEquals(self.viewlet.has_replies(), True)
self.assertEqual(self.viewlet.has_replies(), True)
def test_get_replies(self):
self.failIf(self.viewlet.get_replies())
self.assertFalse(self.viewlet.get_replies())
comment = createObject('plone.Comment')
comment.text = 'Comment text'
conversation = IConversation(self.portal.doc1)
conversation.addComment(comment)
conversation.addComment(comment)
replies = self.viewlet.get_replies()
self.assertEquals(len(tuple(replies)), 2)
self.assertEqual(len(tuple(replies)), 2)
replies = self.viewlet.get_replies()
replies.next()
replies.next()
self.assertRaises(StopIteration, replies.next)
def test_get_replies_with_workflow_actions(self):
self.failIf(self.viewlet.get_replies(workflow_actions=True))
self.assertFalse(self.viewlet.get_replies(workflow_actions=True))
comment = createObject('plone.Comment')
comment.text = 'Comment text'
conversation = IConversation(self.portal.doc1)
c1 = conversation.addComment(comment)
self.assertEquals(
self.assertEqual(
len(tuple(self.viewlet.get_replies(workflow_actions=True))), 1)
# Enable moderation workflow
self.portal.portal_workflow.setChainForPortalTypes(
@ -349,10 +349,10 @@ class TestCommentsViewlet(PloneTestCase):
('comment_review_workflow,'))
# Check if workflow actions are available
reply = self.viewlet.get_replies(workflow_actions=True).next()
self.failUnless(reply.has_key('actions'))
self.assertEquals(reply['actions'][0]['id'],
self.assertTrue(reply.has_key('actions'))
self.assertEqual(reply['actions'][0]['id'],
'publish')
self.assertEquals(reply['actions'][0]['url'],
self.assertEqual(reply['actions'][0]['url'],
'http://nohost/plone/doc1/++conversation++default/%s' % int(c1) +
'/content_status_modify?workflow_action=publish')
@ -362,11 +362,11 @@ class TestCommentsViewlet(PloneTestCase):
IConversation(self.portal.doc1)
portal_membership = getToolByName(self.portal, 'portal_membership')
m = portal_membership.getAuthenticatedMember()
self.assertEquals(self.viewlet.get_commenter_home_url(m.getUserName()),
self.assertEqual(self.viewlet.get_commenter_home_url(m.getUserName()),
'http://nohost/plone/author/portal_owner')
def test_get_commenter_home_url_is_none(self):
self.failIf(self.viewlet.get_commenter_home_url())
self.assertFalse(self.viewlet.get_commenter_home_url())
def test_get_commenter_portrait(self):
@ -393,11 +393,11 @@ class TestCommentsViewlet(PloneTestCase):
portrait_url = self.viewlet.get_commenter_portrait('jim')
# Check if the correct member image URL is returned
self.assertEquals(portrait_url,
self.assertEqual(portrait_url,
'http://nohost/plone/portal_memberdata/portraits/jim')
def test_get_commenter_portrait_is_none(self):
self.assertEquals(self.viewlet.get_commenter_portrait(),
self.assertEqual(self.viewlet.get_commenter_portrait(),
'defaultUser.gif')
def test_get_commenter_portrait_without_userimage(self):
@ -420,35 +420,35 @@ class TestCommentsViewlet(PloneTestCase):
# Check if the correct default member image URL is returned.
# Note that Products.PlonePAS 4.0.5 and later have .png and
# earlier versions have .gif.
self.failUnless(portrait_url in
self.assertTrue(portrait_url in
('http://nohost/plone/defaultUser.png',
'http://nohost/plone/defaultUser.gif'))
def test_anonymous_discussion_allowed(self):
# Anonymous discussion is not allowed by default
self.failIf(self.viewlet.anonymous_discussion_allowed())
self.assertFalse(self.viewlet.anonymous_discussion_allowed())
# Allow anonymous discussion
registry = queryUtility(IRegistry)
registry['plone.app.discussion.interfaces.IDiscussionSettings.' +
'anonymous_comments'] = True
# Test if anonymous discussion is allowed for the viewlet
self.failUnless(self.viewlet.anonymous_discussion_allowed())
self.assertTrue(self.viewlet.anonymous_discussion_allowed())
def test_show_commenter_image(self):
self.failUnless(self.viewlet.show_commenter_image())
self.assertTrue(self.viewlet.show_commenter_image())
registry = queryUtility(IRegistry)
registry['plone.app.discussion.interfaces.IDiscussionSettings.' +
'show_commenter_image'] = False
self.failIf(self.viewlet.show_commenter_image())
self.assertFalse(self.viewlet.show_commenter_image())
def test_is_anonymous(self):
self.failIf(self.viewlet.is_anonymous())
self.assertFalse(self.viewlet.is_anonymous())
self.logout()
self.failUnless(self.viewlet.is_anonymous())
self.assertTrue(self.viewlet.is_anonymous())
def test_login_action(self):
self.viewlet.update()
self.assertEquals(self.viewlet.login_action(),
self.assertEqual(self.viewlet.login_action(),
'http://nohost/plone/login_form?came_from=http%3A//nohost')
def test_format_time(self):
@ -464,7 +464,7 @@ class TestCommentsViewlet(PloneTestCase):
python_time = datetime(
*time.gmtime(time.mktime(python_time.timetuple()))[:7])
localized_time = self.viewlet.format_time(python_time)
self.assertEquals(localized_time, "Feb 01, 2009 11:32 PM")
self.assertEqual(localized_time, "Feb 01, 2009 11:32 PM")
def test_suite():

44
plone/app/discussion/tests/test_controlpanel.py
View File

@ -26,67 +26,67 @@ class RegistryTest(PloneTestCase):
def test_registry_registered(self):
registry = queryUtility(IRegistry)
self.failUnless(registry.forInterface(IDiscussionSettings))
self.assertTrue(registry.forInterface(IDiscussionSettings))
def test_discussion_controlpanel_view(self):
view = getMultiAdapter((self.portal, self.portal.REQUEST),
name="discussion-settings")
view = view.__of__(self.portal)
self.failUnless(view())
self.assertTrue(view())
def test_discussion_in_controlpanel(self):
# Check if discussion is in the control panel
self.controlpanel = getToolByName(self.portal, "portal_controlpanel")
self.failUnless('discussion' in [a.getAction(self)['id']
self.assertTrue('discussion' in [a.getAction(self)['id']
for a in self.controlpanel.listActions()])
def test_globally_enabled(self):
# Check globally_enabled record
self.failUnless('globally_enabled' in IDiscussionSettings)
self.assertEquals(
self.assertTrue('globally_enabled' in IDiscussionSettings)
self.assertEqual(
self.registry['plone.app.discussion.interfaces.' +
'IDiscussionSettings.globally_enabled'],
False)
def test_anonymous_comments(self):
# Check anonymous_comments record
self.failUnless('anonymous_comments' in IDiscussionSettings)
self.assertEquals(self.registry['plone.app.discussion.interfaces.' +
self.assertTrue('anonymous_comments' in IDiscussionSettings)
self.assertEqual(self.registry['plone.app.discussion.interfaces.' +
'IDiscussionSettings.anonymous_comments'], False)
def test_moderation_enabled(self):
# Check globally_enabled record
self.failUnless('moderation_enabled' in IDiscussionSettings)
self.assertEquals(
self.assertTrue('moderation_enabled' in IDiscussionSettings)
self.assertEqual(
self.registry['plone.app.discussion.interfaces.' +
'IDiscussionSettings.moderation_enabled'],
False)
def test_text_transform(self):
self.failUnless('text_transform' in IDiscussionSettings)
self.assertEquals(
self.assertTrue('text_transform' in IDiscussionSettings)
self.assertEqual(
self.registry['plone.app.discussion.interfaces.' +
'IDiscussionSettings.text_transform'],
'text/plain')
def test_captcha(self):
# Check globally_enabled record
self.failUnless('captcha' in IDiscussionSettings)
self.assertEquals(self.registry['plone.app.discussion.interfaces.' +
self.assertTrue('captcha' in IDiscussionSettings)
self.assertEqual(self.registry['plone.app.discussion.interfaces.' +
'IDiscussionSettings.captcha'],
'disabled')
def test_show_commenter_image(self):
# Check show_commenter_image record
self.failUnless('show_commenter_image' in IDiscussionSettings)
self.assertEquals(self.registry['plone.app.discussion.interfaces.' +
self.assertTrue('show_commenter_image' in IDiscussionSettings)
self.assertEqual(self.registry['plone.app.discussion.interfaces.' +
'IDiscussionSettings.show_commenter_image'], True)
def test_moderator_notification_enabled(self):
# Check show_commenter_image record
self.failUnless('moderator_notification_enabled' in
self.assertTrue('moderator_notification_enabled' in
IDiscussionSettings)
self.assertEquals(self.registry['plone.app.discussion.interfaces.' +
self.assertEqual(self.registry['plone.app.discussion.interfaces.' +
'IDiscussionSettings.moderator_notification_enabled'], False)
#def test_user_notification_enabled(self):
@ -94,8 +94,8 @@ class RegistryTest(PloneTestCase):
# show_commenter_image = self.registry.records['plone.app.discussion.' +
# 'interfaces.IDiscussionSettings.user_notification_enabled']
#
# self.failUnless('user_notification_enabled' in IDiscussionSettings)
# self.assertEquals(self.registry['plone.app.discussion.interfaces.' +
# self.assertTrue('user_notification_enabled' in IDiscussionSettings)
# self.assertEqual(self.registry['plone.app.discussion.interfaces.' +
# 'IDiscussionSettings.user_notification_enabled'], False)
@ -115,7 +115,7 @@ class ConfigurationChangedSubscriberTest(PloneTestCase):
changes.
"""
# By default the one_state_workflow without moderation is enabled
self.assertEquals(('one_state_workflow',),
self.assertEqual(('one_state_workflow',),
self.portal.portal_workflow.getChainForPortalType(
'Discussion Item'))
@ -124,12 +124,12 @@ class ConfigurationChangedSubscriberTest(PloneTestCase):
# Make sure the comment_review_workflow with moderation enabled is
# enabled
self.assertEquals(('comment_review_workflow',),
self.assertEqual(('comment_review_workflow',),
self.portal.portal_workflow.getChainForPortalType(
'Discussion Item'))
# And back
self.settings.moderation_enabled = False
self.assertEquals(('one_state_workflow',),
self.assertEqual(('one_state_workflow',),
self.portal.portal_workflow.getChainForPortalType(
'Discussion Item'))

218
plone/app/discussion/tests/test_conversation.py
View File

@ -57,15 +57,15 @@ class ConversationTest(PloneTestCase):
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__),
self.assertTrue(isinstance(comment.comment_id, long))
self.assertTrue(IComment.providedBy(conversation[new_id]))
self.assertEqual(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(len(tuple(conversation.getThreads())), 1)
self.assertEquals(conversation.total_comments, 1)
self.assert_(conversation.last_comment_date - datetime.utcnow() <
self.assertEqual(new_id, comment.comment_id)
self.assertEqual(len(list(conversation.getComments())), 1)
self.assertEqual(len(tuple(conversation.getThreads())), 1)
self.assertEqual(conversation.total_comments, 1)
self.assertTrue(conversation.last_comment_date - datetime.utcnow() <
timedelta(seconds=1))
def test_delete_comment(self):
@ -82,17 +82,17 @@ class ConversationTest(PloneTestCase):
new_id = conversation.addComment(comment)
# make sure the comment has been added
self.assertEquals(len(list(conversation.getComments())), 1)
self.assertEquals(len(tuple(conversation.getThreads())), 1)
self.assertEquals(conversation.total_comments, 1)
self.assertEqual(len(list(conversation.getComments())), 1)
self.assertEqual(len(tuple(conversation.getThreads())), 1)
self.assertEqual(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(len(tuple(conversation.getThreads())), 0)
self.assertEquals(conversation.total_comments, 0)
self.assertEqual(len(list(conversation.getComments())), 0)
self.assertEqual(len(tuple(conversation.getThreads())), 0)
self.assertEqual(conversation.total_comments, 0)
def test_delete_recursive(self):
# Create a conversation. In this case we doesn't assign it to an
@ -148,7 +148,7 @@ class ConversationTest(PloneTestCase):
del conversation[new_id_1]
self.assertEquals(
self.assertEqual(
[{'comment': comment2, 'depth': 0, 'id': new_id_2},
{'comment': comment2_1, 'depth': 1, 'id': new_id_2_1},
], list(conversation.getThreads()))
@ -165,9 +165,9 @@ class ConversationTest(PloneTestCase):
self.portal.manage_delObjects(['doc1'])
# Make sure the comment has been deleted as well
self.assertEquals(len(list(conversation.getComments())), 0)
self.assertEquals(len(tuple(conversation.getThreads())), 0)
self.assertEquals(conversation.total_comments, 0)
self.assertEqual(len(list(conversation.getComments())), 0)
self.assertEqual(len(tuple(conversation.getThreads())), 0)
self.assertEqual(conversation.total_comments, 0)
def test_allow_discussion(self):
# This is not a real test! It's only there to understand the
@ -187,52 +187,52 @@ class ConversationTest(PloneTestCase):
type_fti = getattr(portal_types, type)
if type not in BAD_TYPES:
if type != 'Discussion Item':
self.failIf(type_fti.allowDiscussion())
self.assertFalse(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.assertEqual(portal_discussion.isDiscussionAllowedFor(
self.portal.doc1), False)
self.assertEquals(self.portal.doc1.getTypeInfo().allowDiscussion(),
self.assertEqual(self.portal.doc1.getTypeInfo().allowDiscussion(),
False)
# The allow discussion flag is None by default
self.failIf(getattr(self.portal.doc1, 'allow_discussion', None))
self.assertFalse(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.assertEqual(portal_discussion.isDiscussionAllowedFor(
self.portal.doc1), True)
self.assertEquals(self.portal.doc1.getTypeInfo().allowDiscussion(),
self.assertEqual(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.assertEqual(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),
self.assertEqual(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.assertEqual(portal_discussion.isDiscussionAllowedFor(
self.portal.doc1), False)
self.assertEquals(self.portal.doc1.getTypeInfo().allowDiscussion(),
self.assertEqual(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.assertEqual(portal_discussion.isDiscussionAllowedFor(
self.portal.doc1), True)
self.assertEquals(getattr(self.portal.doc1, 'allow_discussion', None),
self.assertEqual(getattr(self.portal.doc1, 'allow_discussion', None),
True)
def test_comments_enabled_on_doc_in_subfolder(self):
@ -250,7 +250,7 @@ class ConversationTest(PloneTestCase):
doc = self.portal.folder1.doc2
conversation = doc.restrictedTraverse('@@conversation_view')
self.assertEquals(conversation.enabled(), False)
self.assertEqual(conversation.enabled(), False)
# We have to allow discussion on Document content type, since
# otherwise allow_discussion will always return False
@ -258,7 +258,7 @@ class ConversationTest(PloneTestCase):
document_fti = getattr(portal_types, 'Document')
document_fti.manage_changeProperties(allow_discussion = True)
self.assertEquals(conversation.enabled(), True)
self.assertEqual(conversation.enabled(), True)
def test_disable_commenting_globally(self):
@ -273,7 +273,7 @@ class ConversationTest(PloneTestCase):
document_fti.manage_changeProperties(allow_discussion = True)
# Check if conversation is enabled now
self.assertEquals(conversation.enabled(), True)
self.assertEqual(conversation.enabled(), True)
# Disable commenting in the registry
registry = queryUtility(IRegistry)
@ -281,11 +281,11 @@ class ConversationTest(PloneTestCase):
settings.globally_enabled = False
# Check if commenting is disabled on the conversation
self.assertEquals(conversation.enabled(), False)
self.assertEqual(conversation.enabled(), False)
# Enable discussion again
settings.globally_enabled = True
self.assertEquals(conversation.enabled(), True)
self.assertEqual(conversation.enabled(), True)
def test_allow_discussion_for_news_items(self):
@ -301,7 +301,7 @@ class ConversationTest(PloneTestCase):
document_fti.manage_changeProperties(allow_discussion = True)
# Check if conversation is enabled now
self.assertEquals(conversation.enabled(), True)
self.assertEqual(conversation.enabled(), True)
# Disable commenting in the registry
registry = queryUtility(IRegistry)
@ -309,11 +309,11 @@ class ConversationTest(PloneTestCase):
settings.globally_enabled = False
# Check if commenting is disabled on the conversation
self.assertEquals(conversation.enabled(), False)
self.assertEqual(conversation.enabled(), False)
# Enable discussion again
settings.globally_enabled = True
self.assertEquals(conversation.enabled(), True)
self.assertEqual(conversation.enabled(), True)
def test_disable_commenting_for_content_type(self):
@ -322,7 +322,7 @@ class ConversationTest(PloneTestCase):
'@@conversation_view')
# The Document content type is disabled by default
self.assertEquals(conversation.enabled(), False)
self.assertEqual(conversation.enabled(), False)
# Allow discussion on Document content type
portal_types = getToolByName(self.portal, 'portal_types')
@ -330,7 +330,7 @@ class ConversationTest(PloneTestCase):
document_fti.manage_changeProperties(allow_discussion = True)
# Check if conversation is enabled now
self.assertEquals(conversation.enabled(), True)
self.assertEqual(conversation.enabled(), True)
# Disallow discussion on Document content type
portal_types = getToolByName(self.portal, 'portal_types')
@ -338,7 +338,7 @@ class ConversationTest(PloneTestCase):
document_fti.manage_changeProperties(allow_discussion = False)
# Check if conversation is enabled now
self.assertEquals(conversation.enabled(), False)
self.assertEqual(conversation.enabled(), False)
def test_allow_discussion_on_folder(self):
# The enabled method should always return False for the folder
@ -359,7 +359,7 @@ class ConversationTest(PloneTestCase):
document_fti.manage_changeProperties(allow_discussion = True)
# Always return False
self.failIf(conversation.enabled())
self.assertFalse(conversation.enabled())
def test_is_discussion_allowed_for_folder(self):
# When a content item provides IFolderish from CMF and
@ -378,19 +378,19 @@ class ConversationTest(PloneTestCase):
doc1 = self.portal.f1.doc1
doc1_conversation = doc1.restrictedTraverse('@@conversation_view')
self.assertEquals(doc1_conversation.enabled(), False)
self.assertEqual(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)
self.assertEqual(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)
self.assertEqual(doc1_conversation.enabled(), False)
def test_is_discussion_allowed_on_content_object(self):
# Allow discussion on a single content object
@ -400,16 +400,16 @@ class ConversationTest(PloneTestCase):
'@@conversation_view')
# Discussion is disallowed by default
self.assertEquals(conversation.enabled(), False)
self.assertEqual(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.assertEqual(conversation.enabled(), True)
self.portal_discussion.overrideDiscussionFor(self.portal.doc1, False)
self.assertEquals(conversation.enabled(), False)
self.assertEqual(conversation.enabled(), False)
def test_dict_operations(self):
# test dict operations and acquisition wrapping
@ -433,41 +433,41 @@ class ConversationTest(PloneTestCase):
# 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)
self.assertTrue(IComment.providedBy(conversation.get(new_id1)))
self.assertTrue(IComment.providedBy(conversation.get(new_id2)))
self.assertEqual(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())
self.assertEqual(len(conversation.keys()), 2)
self.assertTrue(new_id1 in conversation.keys())
self.assertTrue(new_id2 in conversation.keys())
self.assertFalse(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())
self.assertEqual(len(conversation.items()), 2)
self.assertTrue((new_id1, comment1) in conversation.items())
self.assertTrue((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())
self.assertEqual(len(conversation.values()), 2)
self.assertTrue(comment1 in conversation.values())
self.assertTrue(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())
self.assertTrue(new_id1 in conversation.iterkeys())
self.assertTrue(new_id2 in conversation.iterkeys())
self.assertFalse(123 in conversation.iterkeys())
# check if comment objects are in itervalues
self.failUnless(comment1 in conversation.itervalues())
self.failUnless(comment2 in conversation.itervalues())
self.assertTrue(comment1 in conversation.itervalues())
self.assertTrue(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())
self.assertTrue((new_id1, comment1) in conversation.iteritems())
self.assertTrue((new_id2, comment2) in conversation.iteritems())
# TODO test acquisition wrapping
#self.failUnless(aq_base(aq_parent(comment1)) is conversation)
#self.assertTrue(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
@ -491,7 +491,7 @@ class ConversationTest(PloneTestCase):
conversation.addComment(comment2)
conversation.addComment(comment3)
self.assertEquals(conversation.total_comments, 3)
self.assertEqual(conversation.total_comments, 3)
def test_commentators(self):
# add and remove a few comments to make sure the commentators
@ -501,7 +501,7 @@ class ConversationTest(PloneTestCase):
# object, as we just want to check the Conversation object API.
conversation = IConversation(self.portal.doc1)
self.assertEquals(conversation.total_comments, 0)
self.assertEqual(conversation.total_comments, 0)
# Add a four comments from three different users
# Note: in real life, we always create
@ -528,29 +528,29 @@ class ConversationTest(PloneTestCase):
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)
self.assertEqual(conversation.total_comments, 4)
self.assertTrue('Jim' in conversation.commentators)
self.assertTrue('Joe' in conversation.commentators)
self.assertTrue('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)
self.assertTrue('Jim' in conversation.commentators)
self.assertTrue('Joe' in conversation.commentators)
self.assertTrue('Jack' in conversation.commentators)
self.assertEqual(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)
self.assertTrue('Jim' in conversation.commentators)
self.assertTrue('Joe' in conversation.commentators)
self.assertFalse('Jack' in conversation.commentators)
self.assertEqual(conversation.total_comments, 2)
def test_last_comment_date(self):
# add and remove some comments and check if last_comment_date
@ -580,9 +580,9 @@ class ConversationTest(PloneTestCase):
new_comment3_id = conversation.addComment(comment3)
# check if the latest comment is exactly one day old
self.assert_(conversation.last_comment_date < datetime.utcnow() -
self.assertTrue(conversation.last_comment_date < datetime.utcnow() -
timedelta(hours=23, minutes=59, seconds=59))
self.assert_(conversation.last_comment_date >
self.assertTrue(conversation.last_comment_date >
datetime.utcnow() - timedelta(days=1, seconds=1))
# remove the latest comment
@ -590,9 +590,9 @@ class ConversationTest(PloneTestCase):
# check if the latest comment has been updated
# the latest comment should be exactly two days old
self.assert_(conversation.last_comment_date < datetime.utcnow() -
self.assertTrue(conversation.last_comment_date < datetime.utcnow() -
timedelta(days=1, hours=23, minutes=59, seconds=59))
self.assert_(conversation.last_comment_date > datetime.utcnow() -
self.assertTrue(conversation.last_comment_date > datetime.utcnow() -
timedelta(days=2, seconds=1))
# remove the latest comment again
@ -600,9 +600,9 @@ class ConversationTest(PloneTestCase):
# check if the latest comment has been updated
# the latest comment should be exactly four days old
self.assert_(conversation.last_comment_date < datetime.utcnow() -
self.assertTrue(conversation.last_comment_date < datetime.utcnow() -
timedelta(days=3, hours=23, minutes=59, seconds=59))
self.assert_(conversation.last_comment_date > datetime.utcnow() -
self.assertTrue(conversation.last_comment_date > datetime.utcnow() -
timedelta(days=4, seconds=2))
def test_get_comments_full(self):
@ -666,7 +666,7 @@ class ConversationTest(PloneTestCase):
# Get threads
self.assertEquals(
self.assertEqual(
[{'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},
@ -685,11 +685,11 @@ class ConversationTest(PloneTestCase):
conversation = self.portal.doc1.restrictedTraverse(
'++conversation++default')
self.assert_(IConversation.providedBy(conversation))
self.assertTrue(IConversation.providedBy(conversation))
self.assertEquals(('', 'plone', 'doc1', '++conversation++default'),
self.assertEqual(('', 'plone', 'doc1', '++conversation++default'),
conversation.getPhysicalPath())
self.assertEquals('http://nohost/plone/doc1/++conversation++default',
self.assertEqual('http://nohost/plone/doc1/++conversation++default',
conversation.absolute_url())
def test_parent(self):
@ -699,19 +699,19 @@ class ConversationTest(PloneTestCase):
conversation = IConversation(self.portal.doc1)
# Check the parent
self.failUnless(conversation.__parent__)
self.failUnless(aq_parent(conversation))
self.assertTrue(conversation.__parent__)
self.assertTrue(aq_parent(conversation))
self.assertEquals(conversation.__parent__.getId(), 'doc1')
self.assertEqual(conversation.__parent__.getId(), 'doc1')
def test_discussion_item_not_in_bad_types(self):
self.failIf('Discussion Item' in BAD_TYPES)
self.assertFalse('Discussion Item' in BAD_TYPES)
def test_no_comment(self):
conversation = IConversation(self.portal.doc1)
# Make sure no conversation has been created
self.assert_('plone.app.discussion:conversation' not in
self.assertTrue('plone.app.discussion:conversation' not in
IAnnotations(self.portal.doc1))
@ -742,15 +742,15 @@ class RepliesTest(PloneTestCase):
new_id = replies.addComment(comment)
# check that replies provides the IReplies interface
self.assert_(IReplies.providedBy(replies))
self.assertTrue(IReplies.providedBy(replies))
# Make sure our comment was added
self.failUnless(new_id in replies)
self.assertTrue(new_id in replies)
# Make sure it is also reflected in the conversation
self.failUnless(new_id in conversation)
self.assertTrue(new_id in conversation)
self.assertEquals(conversation[new_id].comment_id, new_id)
self.assertEqual(conversation[new_id].comment_id, new_id)
def test_delete_comment(self):
# Create and remove a comment and check if the replies adapter
@ -769,13 +769,13 @@ class RepliesTest(PloneTestCase):
new_id = replies.addComment(comment)
# make sure the comment has been added
self.assertEquals(len(replies), 1)
self.assertEqual(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)
self.assertEqual(len(replies), 0)
def test_dict_api(self):
# This test is for the ConversationReplies as well as the
@ -842,11 +842,11 @@ class RepliesTest(PloneTestCase):
# 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)
self.assertEqual(conversation.total_comments, 6)
self.assertEqual(len(replies), 2)
self.assertEqual(len(replies_to_comment1), 2)
self.assertEqual(len(replies_to_comment1_1), 1)
self.assertEqual(len(replies_to_comment2), 1)
def test_suite():
return unittest.defaultTestLoader.loadTestsFromName(__name__)

44
plone/app/discussion/tests/test_indexers.py
View File

@ -71,32 +71,32 @@ class ConversationIndexersTest(PloneTestCase):
self.conversation = conversation
def test_conversation_total_comments(self):
self.assert_(isinstance(catalog.total_comments,
self.assertTrue(isinstance(catalog.total_comments,
DelegatingIndexerFactory))
self.assertEquals(catalog.total_comments(self.portal.doc1)(), 3)
self.assertEqual(catalog.total_comments(self.portal.doc1)(), 3)
del self.conversation[self.new_id1]
self.assertEquals(catalog.total_comments(self.portal.doc1)(), 2)
self.assertEqual(catalog.total_comments(self.portal.doc1)(), 2)
del self.conversation[self.new_id2]
del self.conversation[self.new_id3]
self.assertEquals(catalog.total_comments(self.portal.doc1)(), 0)
self.assertEqual(catalog.total_comments(self.portal.doc1)(), 0)
def test_conversation_last_comment_date(self):
self.assert_(isinstance(catalog.last_comment_date,
self.assertTrue(isinstance(catalog.last_comment_date,
DelegatingIndexerFactory))
self.assertEquals(catalog.last_comment_date(self.portal.doc1)(),
self.assertEqual(catalog.last_comment_date(self.portal.doc1)(),
datetime(2009, 4, 12, 11, 12, 12))
del self.conversation[self.new_id3]
self.assertEquals(catalog.last_comment_date(self.portal.doc1)(),
self.assertEqual(catalog.last_comment_date(self.portal.doc1)(),
datetime(2007, 12, 13, 4, 18, 12))
del self.conversation[self.new_id2]
del self.conversation[self.new_id1]
self.assertEquals(catalog.last_comment_date(self.portal.doc1)(), None)
self.assertEqual(catalog.last_comment_date(self.portal.doc1)(), None)
def test_conversation_commentators(self):
pass
#self.assertEquals(catalog.commentators(self.portal.doc1)(),
#self.assertEqual(catalog.commentators(self.portal.doc1)(),
# ('Jim', 'Emma', 'Lukas'))
#self.assert_(isinstance(catalog.commentators,
#self.assertTrue(isinstance(catalog.commentators,
# DelegatingIndexerFactory))
@ -129,13 +129,13 @@ class CommentIndexersTest(PloneTestCase):
self.conversation = conversation
def test_title(self):
self.assertEquals(catalog.title(self.comment)(), 'Jim on Document 1')
self.assert_(isinstance(catalog.title, DelegatingIndexerFactory))
self.assertEqual(catalog.title(self.comment)(), 'Jim on Document 1')
self.assertTrue(isinstance(catalog.title, DelegatingIndexerFactory))
def test_description(self):
self.assertEquals(catalog.description(self.comment)(),
self.assertEqual(catalog.description(self.comment)(),
'Lorem ipsum dolor sit amet.')
self.assert_(isinstance(catalog.description, DelegatingIndexerFactory))
self.assertTrue(isinstance(catalog.description, DelegatingIndexerFactory))
def test_description_long(self):
# Create a 50 word comment and make sure the description returns
@ -145,32 +145,32 @@ class CommentIndexersTest(PloneTestCase):
comment_long.text = LONG_TEXT
self.conversation.addComment(comment_long)
self.assertEquals(catalog.description(comment_long)(),
self.assertEqual(catalog.description(comment_long)(),
LONG_TEXT_CUT.replace("\n", " "))
def test_dates(self):
# Test if created, modified, effective etc. are set correctly
self.assertEquals(catalog.created(self.comment)(),
self.assertEqual(catalog.created(self.comment)(),
DateTime(2006, 9, 17, 14, 18, 12, 'GMT'))
self.assertEquals(catalog.effective(self.comment)(),
self.assertEqual(catalog.effective(self.comment)(),
DateTime(2006, 9, 17, 14, 18, 12, 'GMT'))
self.assertEquals(catalog.modified(self.comment)(),
self.assertEqual(catalog.modified(self.comment)(),
DateTime(2008, 3, 12, 7, 32, 52, 'GMT'))
def test_searchable_text(self):
# Test if searchable text is a concatenation of title and comment text
self.assertEquals(catalog.searchable_text(self.comment)(),
self.assertEqual(catalog.searchable_text(self.comment)(),
('Lorem ipsum dolor sit amet.'))
self.assert_(isinstance(catalog.searchable_text,
self.assertTrue(isinstance(catalog.searchable_text,
DelegatingIndexerFactory))
def test_creator(self):
self.assertEquals(catalog.creator(self.comment)(), ('Jim'))
self.assertEqual(catalog.creator(self.comment)(), ('Jim'))
def test_in_response_to(self):
# make sure in_response_to returns the title or id of the content
# object the comment was added to
self.assertEquals(catalog.in_response_to(self.comment)(), 'Document 1')
self.assertEqual(catalog.in_response_to(self.comment)(), 'Document 1')
def test_suite():

58
plone/app/discussion/tests/test_migration.py
View File

@ -49,37 +49,37 @@ class MigrationTest(PloneTestCase):
reply.setReplyTo(self.doc)
reply.creation_date = DateTime(2003, 3, 11, 9, 28, 6, 'GMT')
reply.modification_date = DateTime(2009, 7, 12, 19, 38, 7, 'GMT')
self.assertEquals(reply.Title(), 'My Title')
self.assertEquals(reply.EditableBody(), 'My Text')
self.failUnless('Jim' in reply.listCreators())
self.assertEquals(talkback.replyCount(self.doc), 1)
self.assertEquals(reply.inReplyTo(), self.doc)
self.assertEqual(reply.Title(), 'My Title')
self.assertEqual(reply.EditableBody(), 'My Text')
self.assertTrue('Jim' in reply.listCreators())
self.assertEqual(talkback.replyCount(self.doc), 1)
self.assertEqual(reply.inReplyTo(), self.doc)
# Call migration script
self.view()
# Make sure a conversation has been created
self.failUnless('plone.app.discussion:conversation' in
self.assertTrue('plone.app.discussion:conversation' in
IAnnotations(self.doc))
conversation = IConversation(self.doc)
# Check migration
self.assertEquals(conversation.total_comments, 1)
self.failUnless(conversation.getComments().next())
self.assertEqual(conversation.total_comments, 1)
self.assertTrue(conversation.getComments().next())
comment1 = conversation.values()[0]
self.assert_(IComment.providedBy(comment1))
self.assertEquals(comment1.Title(), 'My Title')
self.assertEquals(comment1.text, '<p>My Text</p>\n')
self.assertEquals(comment1.mime_type, 'text/html')
self.assertEquals(comment1.Creator(), 'Jim')
self.assertEquals(comment1.creation_date,
self.assertTrue(IComment.providedBy(comment1))
self.assertEqual(comment1.Title(), 'My Title')
self.assertEqual(comment1.text, '<p>My Text</p>\n')
self.assertEqual(comment1.mime_type, 'text/html')
self.assertEqual(comment1.Creator(), 'Jim')
self.assertEqual(comment1.creation_date,
datetime(2003, 3, 11, 9, 28, 6))
self.assertEquals(comment1.modification_date,
self.assertEqual(comment1.modification_date,
datetime(2009, 7, 12, 19, 38, 7))
self.assertEquals(
self.assertEqual(
[{'comment': comment1, 'depth': 0, 'id': long(comment1.id)},]
, list(conversation.getThreads()))
self.failIf(self.doc.talkback)
self.assertFalse(self.doc.talkback)
def test_migrate_nested_comments(self):
# Create some nested comments and migrate them
@ -108,9 +108,9 @@ class MigrationTest(PloneTestCase):
comment1_1 = talkback_comment1.getReplies()[0]
talkback_comment1_1 = self.discussion.getDiscussionFor(comment1_1)
self.assertEquals(len(talkback.getReplies()), 1)
self.assertEquals(len(talkback_comment1.getReplies()), 1)
self.assertEquals(len(talkback_comment1_1.getReplies()), 0)
self.assertEqual(len(talkback.getReplies()), 1)
self.assertEqual(len(talkback_comment1.getReplies()), 1)
self.assertEqual(len(talkback_comment1_1.getReplies()), 0)
#Re: Re: First comment
talkback_comment1_1.createReply(title='Re: Re: First comment',
@ -143,7 +143,7 @@ class MigrationTest(PloneTestCase):
# Check migration
conversation = IConversation(self.doc)
self.assertEquals(conversation.total_comments, 8)
self.assertEqual(conversation.total_comments, 8)
comment1 = conversation.values()[0]
comment1_1 = conversation.values()[1]
@ -154,7 +154,7 @@ class MigrationTest(PloneTestCase):
comment1_4 = conversation.values()[6]
comment2 = conversation.values()[7]
self.assertEquals(
self.assertEqual(
[{'comment': comment1, 'depth': 0, 'id': long(comment1.id)},
{'comment': comment1_1, 'depth': 1, 'id': long(comment1_1.id)},
{'comment': comment1_1_1, 'depth': 2, 'id': long(comment1_1_1.id)},
@ -166,7 +166,7 @@ class MigrationTest(PloneTestCase):
], list(conversation.getThreads()))
talkback = self.discussion.getDiscussionFor(self.doc)
self.assertEquals(len(talkback.getReplies()), 0)
self.assertEqual(len(talkback.getReplies()), 0)
def test_migrate_nested_comments_with_filter(self):
# Create some nested comments and migrate them.
@ -191,9 +191,9 @@ class MigrationTest(PloneTestCase):
comment1_1 = talkback_comment1.getReplies()[0]
talkback_comment1_1 = self.discussion.getDiscussionFor(comment1_1)
self.assertEquals(len(talkback.getReplies()), 1)
self.assertEquals(len(talkback_comment1.getReplies()), 1)
self.assertEquals(len(talkback_comment1_1.getReplies()), 0)
self.assertEqual(len(talkback.getReplies()), 1)
self.assertEqual(len(talkback_comment1.getReplies()), 1)
self.assertEqual(len(talkback_comment1_1.getReplies()), 0)
def deny_comments(reply):
return False
@ -203,9 +203,9 @@ class MigrationTest(PloneTestCase):
# Check migration
conversation = IConversation(self.doc)
self.assertEquals(conversation.total_comments, 0)
self.assertEqual(conversation.total_comments, 0)
talkback = self.discussion.getDiscussionFor(self.doc)
self.assertEquals(len(talkback.getReplies()), 0)
self.assertEqual(len(talkback.getReplies()), 0)
def test_migrate_no_comment(self):
@ -213,7 +213,7 @@ class MigrationTest(PloneTestCase):
self.view()
# Make sure no conversation has been created
self.assert_('plone.app.discussion:conversation' not in
self.assertTrue('plone.app.discussion:conversation' not in
IAnnotations(self.doc))

28
plone/app/discussion/tests/test_moderation_view.py
View File

@ -72,11 +72,11 @@ class ModerationViewTest(PloneTestCase):
# The one_state_workflow does not have a 'pending' state
self.wf_tool.setChainForPortalTypes(('Discussion Item',),
('one_state_workflow,'))
self.assertEquals(self.view.moderation_enabled(), False)
self.assertEqual(self.view.moderation_enabled(), False)
# The comment_review_workflow does have a 'pending' state
self.wf_tool.setChainForPortalTypes(('Discussion Item',),
('comment_review_workflow,'))
self.assertEquals(self.view.moderation_enabled(), True)
self.assertEqual(self.view.moderation_enabled(), True)
def test_old_comments_not_shown_in_moderation_view(self):
# Create an old comment and make sure it is not shown
@ -91,15 +91,15 @@ class ModerationViewTest(PloneTestCase):
reply.setReplyTo(self.portal.doc1)
reply.creation_date = DateTime(2003, 3, 11, 9, 28, 6)
reply.modification_date = DateTime(2009, 7, 12, 19, 38, 7)
self.assertEquals(reply.Title(), 'My Title')
self.assertEquals(reply.EditableBody(), 'My Text')
self.failUnless('Jim' in reply.listCreators())
self.assertEquals(talkback.replyCount(self.portal.doc1), 1)
self.assertEquals(reply.inReplyTo(), self.portal.doc1)
self.assertEqual(reply.Title(), 'My Title')
self.assertEqual(reply.EditableBody(), 'My Text')
self.assertTrue('Jim' in reply.listCreators())
self.assertEqual(talkback.replyCount(self.portal.doc1), 1)
self.assertEqual(reply.inReplyTo(), self.portal.doc1)
# Make sure only the two new comments are shown
self.view()
self.assertEquals(len(self.view.comments), 3)
self.assertEqual(len(self.view.comments), 3)
class ModerationBulkActionsViewTest(PloneTestCase):
@ -157,7 +157,7 @@ class ModerationBulkActionsViewTest(PloneTestCase):
self.request.set('form.select.BulkAction', '-1')
self.request.set('paths', ['/'.join(self.comment1.getPhysicalPath())])
view = BulkActionsView(self.context, self.request)
self.failIf(view())
self.assertFalse(view())
def test_retract(self):
self.request = self.app.REQUEST
@ -186,7 +186,7 @@ class ModerationBulkActionsViewTest(PloneTestCase):
published_comments += 1
# Make sure the comment has been published
self.assertEquals(published_comments, 1)
self.assertEqual(published_comments, 1)
def test_mark_as_spam(self):
self.request = self.app.REQUEST
@ -203,7 +203,7 @@ class ModerationBulkActionsViewTest(PloneTestCase):
self.context = self.app
# Initially we have three comments
self.assertEquals(self.conversation.total_comments, 3)
self.assertEqual(self.conversation.total_comments, 3)
# Delete two comments with bulk actions
self.request.set('form.select.BulkAction', 'delete')
@ -213,10 +213,10 @@ class ModerationBulkActionsViewTest(PloneTestCase):
view()
# Make sure that the two comments have been deleted
self.assertEquals(self.conversation.total_comments, 1)
self.assertEqual(self.conversation.total_comments, 1)
comment = self.conversation.getComments().next()
self.failUnless(comment)
self.assertEquals(comment, self.comment2)
self.assertTrue(comment)
self.assertEqual(comment, self.comment2)
def test_suite():
return unittest.defaultTestLoader.loadTestsFromName(__name__)

44
plone/app/discussion/tests/test_notifications.py
View File

@ -68,11 +68,11 @@ class TestUserNotificationUnit(PloneTestCase):
comment = createObject('plone.Comment')
comment.text = 'Comment text'
self.conversation.addComment(comment)
self.assertEquals(len(self.mailhost.messages), 1)
self.failUnless(self.mailhost.messages[0])
self.assertEqual(len(self.mailhost.messages), 1)
self.assertTrue(self.mailhost.messages[0])
msg = str(self.mailhost.messages[0])
self.failUnless('To: john@plone.test' in msg)
self.failUnless('From: portal@plone.test' in msg)
self.assertTrue('To: john@plone.test' in msg)
self.assertTrue('From: portal@plone.test' in msg)
# We expect the headers to be properly header encoded (7-bit):
#>>> 'Subject: =?utf-8?q?Some_t=C3=A4st_subject=2E?=' in msg
@ -100,7 +100,7 @@ class TestUserNotificationUnit(PloneTestCase):
comment.text = 'Comment text'
self.conversation.addComment(comment)
self.assertEquals(len(self.mailhost.messages), 0)
self.assertEqual(len(self.mailhost.messages), 0)
def test_do_not_notify_user_when_email_address_is_given(self):
comment = createObject('plone.Comment')
@ -112,7 +112,7 @@ class TestUserNotificationUnit(PloneTestCase):
comment.text = 'Comment text'
self.conversation.addComment(comment)
self.assertEquals(len(self.mailhost.messages), 0)
self.assertEqual(len(self.mailhost.messages), 0)
def test_do_not_notify_user_when_no_sender_is_available(self):
# Set sender mail address to none and make sure no email is send to
@ -129,7 +129,7 @@ class TestUserNotificationUnit(PloneTestCase):
comment.text = 'Comment text'
self.conversation.addComment(comment)
self.assertEquals(len(self.mailhost.messages), 0)
self.assertEqual(len(self.mailhost.messages), 0)
def test_notify_only_once(self):
# When a user has added two comments in a conversation and has
@ -151,19 +151,19 @@ class TestUserNotificationUnit(PloneTestCase):
self.conversation.addComment(comment)
# Note that we might want to get rid of this message, as the
# new comment is added by the same user.
self.assertEquals(len(self.mailhost.messages), 1)
self.assertEqual(len(self.mailhost.messages), 1)
self.mailhost.reset()
self.assertEquals(len(self.mailhost.messages), 0)
self.assertEqual(len(self.mailhost.messages), 0)
# Comment 3
comment = createObject('plone.Comment')
comment.text = 'Comment text'
self.conversation.addComment(comment)
self.assertEquals(len(self.mailhost.messages), 1)
self.failUnless(self.mailhost.messages[0])
self.assertEqual(len(self.mailhost.messages), 1)
self.assertTrue(self.mailhost.messages[0])
msg = str(self.mailhost.messages[0])
self.failUnless('To: john@plone.test' in msg)
self.failUnless('From: portal@plone.test' in msg)
self.assertTrue('To: john@plone.test' in msg)
self.assertTrue('From: portal@plone.test' in msg)
class TestModeratorNotificationUnit(PloneTestCase):
@ -215,12 +215,12 @@ class TestModeratorNotificationUnit(PloneTestCase):
comment.text = 'Comment text'
self.conversation.addComment(comment)
self.assertEquals(len(self.mailhost.messages), 1)
self.failUnless(self.mailhost.messages[0])
self.assertEqual(len(self.mailhost.messages), 1)
self.assertTrue(self.mailhost.messages[0])
msg = self.mailhost.messages[0]
self.failUnless('To: portal@plone.test' in msg)
self.failUnless('From: portal@plone.test' in msg)
self.assertTrue('To: portal@plone.test' in msg)
self.assertTrue('From: portal@plone.test' in msg)
#We expect the headers to be properly header encoded (7-bit):
#>>> 'Subject: =?utf-8?q?Some_t=C3=A4st_subject=2E?=' in msg
@ -243,12 +243,12 @@ class TestModeratorNotificationUnit(PloneTestCase):
comment.text = 'Comment text'
self.conversation.addComment(comment)
self.assertEquals(len(self.mailhost.messages), 1)
self.assertEqual(len(self.mailhost.messages), 1)
msg = self.mailhost.messages[0]
if not isinstance(msg, str):
self.failUnless('test@example.com' in msg.mto)
self.assertTrue('test@example.com' in msg.mto)
else:
self.failUnless('To: test@example.com' in msg)
self.assertTrue('To: test@example.com' in msg)
def test_do_not_notify_moderator_when_no_sender_is_available(self):
# Set sender mail address to nonw and make sure no email is send to the
@ -258,7 +258,7 @@ class TestModeratorNotificationUnit(PloneTestCase):
comment = createObject('plone.Comment')
comment.text = 'Comment text'
self.conversation.addComment(comment)
self.assertEquals(len(self.mailhost.messages), 0)
self.assertEqual(len(self.mailhost.messages), 0)
def test_do_not_notify_moderator_when_notification_is_disabled(self):
# Disable moderator notification setting and make sure no email is send
@ -270,7 +270,7 @@ class TestModeratorNotificationUnit(PloneTestCase):
comment = createObject('plone.Comment')
comment.text = 'Comment text'
self.conversation.addComment(comment)
self.assertEquals(len(self.mailhost.messages), 0)
self.assertEqual(len(self.mailhost.messages), 0)
def test_suite():
return unittest.defaultTestLoader.loadTestsFromName(__name__)

4
plone/app/discussion/tests/test_tool.py
View File

@ -33,9 +33,9 @@ class ToolTest(PloneTestCase):
# Check that the comment got indexed in the tool:
tool = queryUtility(ICommentingTool)
comment = list(tool.searchResults())
self.assert_(len(comment) == 1, "There is only one comment, but we got"
self.assertTrue(len(comment) == 1, "There is only one comment, but we got"
" %s results in the search" % len(comment))
self.assertEquals(comment[0].Title, 'Jim on Document 1')
self.assertEqual(comment[0].Title, 'Jim on Document 1')
def test_unindexing(self):
pass

44
plone/app/discussion/tests/test_workflow.py
View File

@ -35,15 +35,15 @@ class WorkflowSetupTest(PloneTestCase):
def test_workflows_installed(self):
"""Make sure both comment workflows have been installed properly.
"""
self.failUnless('one_state_workflow' in
self.assertTrue('one_state_workflow' in
self.portal.portal_workflow.objectIds())
self.failUnless('comment_review_workflow' in
self.assertTrue('comment_review_workflow' in
self.portal.portal_workflow.objectIds())
def test_default_workflow(self):
"""Make sure one_state_workflow is the default workflow.
"""
self.assertEquals(('one_state_workflow',),
self.assertEqual(('one_state_workflow',),
self.portal.portal_workflow.getChainForPortalType(
'Discussion Item'))
@ -51,10 +51,10 @@ class WorkflowSetupTest(PloneTestCase):
#'Review comments' in self.portal.permissionsOfRole('Admin')
self.setRoles(('Reviewer',))
self.failUnless(self.portal.portal_membership.checkPermission(
self.assertTrue(self.portal.portal_membership.checkPermission(
'Review comments', self.folder), self.folder)
self.setRoles(('Member',))
self.failIf(self.portal.portal_membership.checkPermission(
self.assertFalse(self.portal.portal_membership.checkPermission(
'Review comments', self.folder), self.folder)
def test_reply_to_item_permission(self):
@ -79,16 +79,16 @@ class PermissionsSetupTest(PloneTestCase):
"""
ReplyToItemPerm = "Reply to item"
# should be allowed as Member
self.failUnless(self.checkPermission(ReplyToItemPerm, self.portal))
self.assertTrue(self.checkPermission(ReplyToItemPerm, self.portal))
# should be allowed as Authenticated
self.setRoles(['Authenticated'])
self.failUnless(self.checkPermission(ReplyToItemPerm, self.portal))
self.assertTrue(self.checkPermission(ReplyToItemPerm, self.portal))
# should be allowed as Manager
self.setRoles(['Manager'])
self.failUnless(self.checkPermission(ReplyToItemPerm, self.portal))
self.assertTrue(self.checkPermission(ReplyToItemPerm, self.portal))
# should not be allowed as anonymous
self.logout()
self.failIf(self.checkPermission(ReplyToItemPerm, self.portal))
self.assertFalse(self.checkPermission(ReplyToItemPerm, self.portal))
class CommentOneStateWorkflowTest(PloneTestCase):
@ -133,22 +133,22 @@ class CommentOneStateWorkflowTest(PloneTestCase):
"""
# Owner is allowed
#self.login(default_user)
#self.failUnless(checkPerm(View, self.doc))
#self.assertTrue(checkPerm(View, self.doc))
# Member is allowed
self.login('member')
self.failUnless(checkPerm(View, self.comment))
self.assertTrue(checkPerm(View, self.comment))
# Reviewer is allowed
self.login('reviewer')
self.failUnless(checkPerm(View, self.comment))
self.assertTrue(checkPerm(View, self.comment))
# Anonymous is allowed
self.logout()
self.failUnless(checkPerm(View, self.comment))
self.assertTrue(checkPerm(View, self.comment))
# Editor is allowed
self.login('editor')
self.failUnless(checkPerm(View, self.comment))
self.assertTrue(checkPerm(View, self.comment))
# Reader is allowed
self.login('reader')
self.failUnless(checkPerm(View, self.comment))
self.assertTrue(checkPerm(View, self.comment))
class CommentReviewWorkflowTest(PloneTestCase):
@ -193,7 +193,7 @@ class CommentReviewWorkflowTest(PloneTestCase):
self.portal.REQUEST.form['comment_id'] = self.comment_id
view = self.comment.restrictedTraverse('@@moderate-delete-comment')
view()
self.failIf(self.comment_id in self.conversation.objectIds())
self.assertFalse(self.comment_id in self.conversation.objectIds())
def test_delete_as_anonymous(self):
# Make sure that anonymous users can not delete comments
@ -202,7 +202,7 @@ class CommentReviewWorkflowTest(PloneTestCase):
self.assertRaises(Unauthorized,
self.comment.restrictedTraverse,
'@@moderate-delete-comment')
self.failUnless(self.comment_id in self.conversation.objectIds())
self.assertTrue(self.comment_id in self.conversation.objectIds())
def test_delete_as_user(self):
# Make sure that members can not delete comments
@ -212,29 +212,29 @@ class CommentReviewWorkflowTest(PloneTestCase):
self.assertRaises(Unauthorized,
self.comment.restrictedTraverse,
'@@moderate-delete-comment')
self.failUnless(self.comment_id in self.conversation.objectIds())
self.assertTrue(self.comment_id in self.conversation.objectIds())
def test_publish(self):
self.portal.REQUEST.form['comment_id'] = self.comment_id
self.portal.REQUEST.form['workflow_action'] = 'publish'
self.assertEquals('pending',
self.assertEqual('pending',
self.portal.portal_workflow.getInfoFor(
self.comment, 'review_state'))
view = self.comment.restrictedTraverse('@@moderate-publish-comment')
view()
self.assertEquals('published', self.portal.portal_workflow.\
self.assertEqual('published', self.portal.portal_workflow.\
getInfoFor(self.comment, 'review_state'))
def test_publish_as_anonymous(self):
self.logout()
self.portal.REQUEST.form['comment_id'] = self.comment_id
self.portal.REQUEST.form['workflow_action'] = 'publish'
self.assertEquals('pending', self.portal.portal_workflow.\
self.assertEqual('pending', self.portal.portal_workflow.\
getInfoFor(self.comment, 'review_state'))
self.assertRaises(Unauthorized,
self.comment.restrictedTraverse,
'@@moderate-publish-comment')
self.assertEquals('pending', self.portal.portal_workflow.\
self.assertEqual('pending', self.portal.portal_workflow.\
getInfoFor(self.comment, 'review_state'))
def test_suite():