From 9db8909ea7a1178414cbe66195cc28f0e65ac158 Mon Sep 17 00:00:00 2001
From: Hanno Schlichting <hanno@hannosch.eu>
Date: Fri, 15 Apr 2011 16:23:38 +0000
Subject: [PATCH] Avoid using deprecated test assertions, see
 http://docs.python.org/dev/library/unittest.html#deprecated-aliases for the
 full list

svn path=/plone.app.discussion/trunk/; revision=48881
---
 .../discussion/tests/qunit/QUnitAdapter.js    |   2 +-
 plone/app/discussion/tests/test_catalog.py    |  84 +++----
 plone/app/discussion/tests/test_comment.py    |  86 +++----
 .../discussion/tests/test_comments_viewlet.py |  88 +++----
 .../app/discussion/tests/test_controlpanel.py |  44 ++--
 .../app/discussion/tests/test_conversation.py | 218 +++++++++---------
 plone/app/discussion/tests/test_indexers.py   |  44 ++--
 plone/app/discussion/tests/test_migration.py  |  58 ++---
 .../discussion/tests/test_moderation_view.py  |  28 +--
 .../discussion/tests/test_notifications.py    |  44 ++--
 plone/app/discussion/tests/test_tool.py       |   4 +-
 plone/app/discussion/tests/test_workflow.py   |  44 ++--
 12 files changed, 372 insertions(+), 372 deletions(-)

diff --git a/plone/app/discussion/tests/qunit/QUnitAdapter.js b/plone/app/discussion/tests/qunit/QUnitAdapter.js
index 5521ae2..a3fc18c 100644
--- a/plone/app/discussion/tests/qunit/QUnitAdapter.js
+++ b/plone/app/discussion/tests/qunit/QUnitAdapter.js
@@ -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() {
diff --git a/plone/app/discussion/tests/test_catalog.py b/plone/app/discussion/tests/test_catalog.py
index 44486d2..e0e4092 100644
--- a/plone/app/discussion/tests/test_catalog.py
+++ b/plone/app/discussion/tests/test_catalog.py
@@ -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))
 
 
diff --git a/plone/app/discussion/tests/test_comment.py b/plone/app/discussion/tests/test_comment.py
index c778e37..12567f4 100644
--- a/plone/app/discussion/tests/test_comment.py
+++ b/plone/app/discussion/tests/test_comment.py
@@ -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())
 
diff --git a/plone/app/discussion/tests/test_comments_viewlet.py b/plone/app/discussion/tests/test_comments_viewlet.py
index ca8c4e6..3485874 100644
--- a/plone/app/discussion/tests/test_comments_viewlet.py
+++ b/plone/app/discussion/tests/test_comments_viewlet.py
@@ -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():
diff --git a/plone/app/discussion/tests/test_controlpanel.py b/plone/app/discussion/tests/test_controlpanel.py
index 3be32c0..a2e9d99 100644
--- a/plone/app/discussion/tests/test_controlpanel.py
+++ b/plone/app/discussion/tests/test_controlpanel.py
@@ -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'))
 
diff --git a/plone/app/discussion/tests/test_conversation.py b/plone/app/discussion/tests/test_conversation.py
index 6cc8b30..bf7b74d 100644
--- a/plone/app/discussion/tests/test_conversation.py
+++ b/plone/app/discussion/tests/test_conversation.py
@@ -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__)
diff --git a/plone/app/discussion/tests/test_indexers.py b/plone/app/discussion/tests/test_indexers.py
index 0b1166b..5b33164 100644
--- a/plone/app/discussion/tests/test_indexers.py
+++ b/plone/app/discussion/tests/test_indexers.py
@@ -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():
diff --git a/plone/app/discussion/tests/test_migration.py b/plone/app/discussion/tests/test_migration.py
index 564091e..98a4980 100644
--- a/plone/app/discussion/tests/test_migration.py
+++ b/plone/app/discussion/tests/test_migration.py
@@ -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))
 
 
diff --git a/plone/app/discussion/tests/test_moderation_view.py b/plone/app/discussion/tests/test_moderation_view.py
index 0a47088..b722b0c 100644
--- a/plone/app/discussion/tests/test_moderation_view.py
+++ b/plone/app/discussion/tests/test_moderation_view.py
@@ -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__)
diff --git a/plone/app/discussion/tests/test_notifications.py b/plone/app/discussion/tests/test_notifications.py
index b78e86a..262385c 100644
--- a/plone/app/discussion/tests/test_notifications.py
+++ b/plone/app/discussion/tests/test_notifications.py
@@ -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__)
diff --git a/plone/app/discussion/tests/test_tool.py b/plone/app/discussion/tests/test_tool.py
index f2d3218..9a4f28d 100644
--- a/plone/app/discussion/tests/test_tool.py
+++ b/plone/app/discussion/tests/test_tool.py
@@ -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
diff --git a/plone/app/discussion/tests/test_workflow.py b/plone/app/discussion/tests/test_workflow.py
index eecb72b..bd293b0 100644
--- a/plone/app/discussion/tests/test_workflow.py
+++ b/plone/app/discussion/tests/test_workflow.py
@@ -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():