Tests pass (Python 2.7, Django 1.5).

@@ -2,11 +2,12 @@ from __future__ import unicode_literals
 
 
 from django.contrib import admin
 from django.contrib import admin
 from django.contrib.auth import get_user_model
 from django.contrib.auth import get_user_model
-from django.utils.translation import ugettext_lazy as _, ungettext, ungettext_lazy
-from django.contrib.comments.views.moderation import perform_flag, perform_approve, perform_delete
+from django.utils.translation import ugettext_lazy as _, ungettext
 
 
-from django_comments import get_model
 from django_comments.models import Comment
 from django_comments.models import Comment
+from django_comments import get_model
+from django_comments.views.moderation import perform_flag, perform_approve, perform_delete
+
 
 
 class UsernameSearch(object):
 class UsernameSearch(object):
     """The User object may not be auth.User, so we need to provide
     """The User object may not be auth.User, so we need to provide
@@ -43,7 +44,7 @@ class CommentsAdmin(admin.ModelAdmin):
         # Only superusers should be able to delete the comments from the DB.
         # Only superusers should be able to delete the comments from the DB.
         if not request.user.is_superuser and 'delete_selected' in actions:
         if not request.user.is_superuser and 'delete_selected' in actions:
             actions.pop('delete_selected')
             actions.pop('delete_selected')
-        if not request.user.has_perm('comments.can_moderate'):
+        if not request.user.has_perm('django_comments.can_moderate'):
             if 'approve_comments' in actions:
             if 'approve_comments' in actions:
                 actions.pop('approve_comments')
                 actions.pop('approve_comments')
             if 'remove_comments' in actions:
             if 'remove_comments' in actions:
@@ -52,20 +53,17 @@ class CommentsAdmin(admin.ModelAdmin):
 
 
     def flag_comments(self, request, queryset):
     def flag_comments(self, request, queryset):
         self._bulk_flag(request, queryset, perform_flag,
         self._bulk_flag(request, queryset, perform_flag,
-                        ungettext_lazy('%d comment was successfully flagged',
-                                       '%d comments were successfully flagged'))
+                        lambda n: ungettext('flagged', 'flagged', n))
     flag_comments.short_description = _("Flag selected comments")
     flag_comments.short_description = _("Flag selected comments")
 
 
     def approve_comments(self, request, queryset):
     def approve_comments(self, request, queryset):
         self._bulk_flag(request, queryset, perform_approve,
         self._bulk_flag(request, queryset, perform_approve,
-                        ungettext_lazy('%d comment was successfully approved',
-                                       '%d comments were successfully approved'))
+                        lambda n: ungettext('approved', 'approved', n))
     approve_comments.short_description = _("Approve selected comments")
     approve_comments.short_description = _("Approve selected comments")
 
 
     def remove_comments(self, request, queryset):
     def remove_comments(self, request, queryset):
         self._bulk_flag(request, queryset, perform_delete,
         self._bulk_flag(request, queryset, perform_delete,
-                        ungettext_lazy('%d comment was successfully removed',
-                                       '%d comments were successfully removed'))
+                        lambda n: ungettext('removed', 'removed', n))
     remove_comments.short_description = _("Remove selected comments")
     remove_comments.short_description = _("Remove selected comments")
 
 
     def _bulk_flag(self, request, queryset, action, done_message):
     def _bulk_flag(self, request, queryset, action, done_message):
@@ -78,7 +76,10 @@ class CommentsAdmin(admin.ModelAdmin):
             action(request, comment)
             action(request, comment)
             n_comments += 1
             n_comments += 1
 
 
-        self.message_user(request, done_message % n_comments)
+        msg = ungettext('1 comment was successfully %(action)s.',
+                        '%(count)s comments were successfully %(action)s.',
+                        n_comments)
+        self.message_user(request, msg % {'count': n_comments, 'action': done_message(n_comments)})
 
 
 # Only register the default admin if the model is the built-in comment model
 # Only register the default admin if the model is the built-in comment model
 # (this won't be true if there's a custom comment app).
 # (this won't be true if there's a custom comment app).

@@ -8,7 +8,7 @@ class CommentManager(models.Manager):
         """
         """
         QuerySet for all comments currently in the moderation queue.
         QuerySet for all comments currently in the moderation queue.
         """
         """
-        return self.get_queryset().filter(is_public=False, is_removed=False)
+        return self.get_query_set().filter(is_public=False, is_removed=False)
 
 
     def for_model(self, model):
     def for_model(self, model):
         """
         """
@@ -16,7 +16,7 @@ class CommentManager(models.Manager):
         a class).
         a class).
         """
         """
         ct = ContentType.objects.get_for_model(model)
         ct = ContentType.objects.get_for_model(model)
-        qs = self.get_queryset().filter(content_type=ct)
+        qs = self.get_query_set().filter(content_type=ct)
         if isinstance(model, models.Model):
         if isinstance(model, models.Model):
             qs = qs.filter(object_pk=force_text(model._get_pk_val()))
             qs = qs.filter(object_pk=force_text(model._get_pk_val()))
         return qs
         return qs

@@ -303,7 +303,7 @@ class Moderator(object):
             model_or_iterable = [model_or_iterable]
             model_or_iterable = [model_or_iterable]
         for model in model_or_iterable:
         for model in model_or_iterable:
             if model in self._registry:
             if model in self._registry:
-                raise AlreadyModerated("The model '%s' is already being moderated" % model._meta.model_name)
+                raise AlreadyModerated("The model '%s' is already being moderated" % model._meta.module_name)
             self._registry[model] = moderation_class(model)
             self._registry[model] = moderation_class(model)
 
 
     def unregister(self, model_or_iterable):
     def unregister(self, model_or_iterable):
@@ -319,7 +319,7 @@ class Moderator(object):
             model_or_iterable = [model_or_iterable]
             model_or_iterable = [model_or_iterable]
         for model in model_or_iterable:
         for model in model_or_iterable:
             if model not in self._registry:
             if model not in self._registry:
-                raise NotModerated("The model '%s' is not currently being moderated" % model._meta.model_name)
+                raise NotModerated("The model '%s' is not currently being moderated" % model._meta.module_name)
             del self._registry[model]
             del self._registry[model]
 
 
     def pre_save_moderation(self, sender, comment, request, **kwargs):
     def pre_save_moderation(self, sender, comment, request, **kwargs):

@@ -2,8 +2,6 @@ from django import template
 from django.template.loader import render_to_string
 from django.template.loader import render_to_string
 from django.conf import settings
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.contenttypes.models import ContentType
-from django.utils import six
-from django.utils.deprecation import RenameMethodsBase
 from django.utils.encoding import smart_text
 from django.utils.encoding import smart_text
 
 
 import django_comments
 import django_comments
@@ -11,13 +9,7 @@ import django_comments
 register = template.Library()
 register = template.Library()
 
 
 
 
-class RenameBaseCommentNodeMethods(RenameMethodsBase):
-    renamed_methods = (
-        ('get_query_set', 'get_queryset', PendingDeprecationWarning),
-    )
-
-
-class BaseCommentNode(six.with_metaclass(RenameBaseCommentNodeMethods, template.Node)):
+class BaseCommentNode(template.Node):
     """
     """
     Base helper class (abstract) for handling the get_comment_* template tags.
     Base helper class (abstract) for handling the get_comment_* template tags.
     Looks a bit strange, but the subclasses below should make this a bit more
     Looks a bit strange, but the subclasses below should make this a bit more
@@ -74,11 +66,11 @@ class BaseCommentNode(six.with_metaclass(RenameBaseCommentNodeMethods, template.
         self.comment = comment
         self.comment = comment
 
 
     def render(self, context):
     def render(self, context):
-        qs = self.get_queryset(context)
+        qs = self.get_query_set(context)
         context[self.as_varname] = self.get_context_value_from_queryset(context, qs)
         context[self.as_varname] = self.get_context_value_from_queryset(context, qs)
         return ''
         return ''
 
 
-    def get_queryset(self, context):
+    def get_query_set(self, context):
         ctype, object_pk = self.get_target_ctype_pk(context)
         ctype, object_pk = self.get_target_ctype_pk(context)
         if not object_pk:
         if not object_pk:
             return self.comment_model.objects.none()
             return self.comment_model.objects.none()
@@ -215,7 +207,7 @@ class RenderCommentListNode(CommentListNode):
                 "comments/%s/list.html" % ctype.app_label,
                 "comments/%s/list.html" % ctype.app_label,
                 "comments/list.html"
                 "comments/list.html"
             ]
             ]
-            qs = self.get_queryset(context)
+            qs = self.get_query_set(context)
             context.push()
             context.push()
             liststr = render_to_string(template_search_list, {
             liststr = render_to_string(template_search_list, {
                 "comment_list" : self.get_context_value_from_queryset(context, qs)
                 "comment_list" : self.get_context_value_from_queryset(context, qs)

@@ -86,10 +86,10 @@ def post_comment(request, next=None, using=None):
             # These first two exist for purely historical reasons.
             # These first two exist for purely historical reasons.
             # Django v1.0 and v1.1 allowed the underscore format for
             # Django v1.0 and v1.1 allowed the underscore format for
             # preview templates, so we have to preserve that format.
             # preview templates, so we have to preserve that format.
-            "comments/%s_%s_preview.html" % (model._meta.app_label, model._meta.model_name),
+            "comments/%s_%s_preview.html" % (model._meta.app_label, model._meta.module_name),
             "comments/%s_preview.html" % model._meta.app_label,
             "comments/%s_preview.html" % model._meta.app_label,
             # Now the usual directory based template hierarchy.
             # Now the usual directory based template hierarchy.
-            "comments/%s/%s/preview.html" % (model._meta.app_label, model._meta.model_name),
+            "comments/%s/%s/preview.html" % (model._meta.app_label, model._meta.module_name),
             "comments/%s/preview.html" % model._meta.app_label,
             "comments/%s/preview.html" % model._meta.app_label,
             "comments/preview.html",
             "comments/preview.html",
         ]
         ]

@@ -37,7 +37,7 @@ def flag(request, comment_id, next=None):
         )
         )
 
 
 @csrf_protect
 @csrf_protect
-@permission_required("comments.can_moderate")
+@permission_required("django_comments.can_moderate")
 def delete(request, comment_id, next=None):
 def delete(request, comment_id, next=None):
     """
     """
     Deletes a comment. Confirmation on GET, action on POST. Requires the "can
     Deletes a comment. Confirmation on GET, action on POST. Requires the "can
@@ -65,7 +65,7 @@ def delete(request, comment_id, next=None):
         )
         )
 
 
 @csrf_protect
 @csrf_protect
-@permission_required("comments.can_moderate")
+@permission_required("django_comments.can_moderate")
 def approve(request, comment_id, next=None):
 def approve(request, comment_id, next=None):
     """
     """
     Approve a comment (that is, mark it as public and non-removed). Confirmation
     Approve a comment (that is, mark it as public and non-removed). Confirmation

@@ -17,6 +17,7 @@ settings.configure(
     INSTALLED_APPS = [
     INSTALLED_APPS = [
         "django.contrib.auth",
         "django.contrib.auth",
         "django.contrib.contenttypes",
         "django.contrib.contenttypes",
+        "django.contrib.sessions",
         "django.contrib.sites",
         "django.contrib.sites",
         "django.contrib.admin",
         "django.contrib.admin",
         "django_comments",
         "django_comments",
@@ -31,8 +32,8 @@ settings.configure(
 from django.test.simple import DjangoTestSuiteRunner
 from django.test.simple import DjangoTestSuiteRunner
 
 
 def main():
 def main():
-    runner = DjangoTestSuiteRunner()
-    failures = runner.run_tests(['testapp'], verbosity=1, interactive=True)
+    runner = DjangoTestSuiteRunner(failfast=True, verbosity=1)
+    failures = runner.run_tests(['testapp'], interactive=True)
     sys.exit(failures)
     sys.exit(failures)
 
 
 if __name__ == '__main__':
 if __name__ == '__main__':

+A comment has been posted on {{ content_object }}.
+The comment reads as follows:
+{{ comment }}

@@ -94,3 +94,4 @@ from .templatetag_tests import *
 from .comment_view_tests import *
 from .comment_view_tests import *
 from .moderation_view_tests import *
 from .moderation_view_tests import *
 from .comment_utils_moderators_tests import *
 from .comment_utils_moderators_tests import *
+

 from __future__ import absolute_import
 from __future__ import absolute_import
 
 
 from django.core import mail
 from django.core import mail
+from django.test.utils import override_settings
 
 
 from django_comments.models import Comment
 from django_comments.models import Comment
 from django_comments.moderation import (moderator, CommentModerator,
 from django_comments.moderation import (moderator, CommentModerator,
@@ -68,9 +69,10 @@ class CommentUtilsModeratorTests(CommentTestCase):
         self.assertRaises(AlreadyModerated, moderator.register, Entry, EntryModerator1)
         self.assertRaises(AlreadyModerated, moderator.register, Entry, EntryModerator1)
 
 
     def testEmailNotification(self):
     def testEmailNotification(self):
-        moderator.register(Entry, EntryModerator1)
-        self.createSomeComments()
-        self.assertEqual(len(mail.outbox), 2)
+        with override_settings(MANAGERS=("test@example.com",)):
+            moderator.register(Entry, EntryModerator1)
+            self.createSomeComments()
+            self.assertEqual(len(mail.outbox), 2)
 
 
     def testCommentsEnabled(self):
     def testCommentsEnabled(self):
         moderator.register(Entry, EntryModerator2)
         moderator.register(Entry, EntryModerator2)

@@ -262,7 +262,7 @@ class AdminActionsTests(CommentTestCase):
         u = User.objects.get(username="normaluser")
         u = User.objects.get(username="normaluser")
         u.is_staff = True
         u.is_staff = True
         perms = Permission.objects.filter(
         perms = Permission.objects.filter(
-            content_type__app_label = 'comments',
+            content_type__app_label = 'django_comments',
             codename__endswith = 'comment'
             codename__endswith = 'comment'
         )
         )
         for perm in perms:
         for perm in perms:
@@ -272,31 +272,34 @@ class AdminActionsTests(CommentTestCase):
     def testActionsNonModerator(self):
     def testActionsNonModerator(self):
         comments = self.createSomeComments()
         comments = self.createSomeComments()
         self.client.login(username="normaluser", password="normaluser")
         self.client.login(username="normaluser", password="normaluser")
-        response = self.client.get("/admin/comments/comment/")
+        response = self.client.get("/admin/django_comments/comment/")
         self.assertNotContains(response, "approve_comments")
         self.assertNotContains(response, "approve_comments")
 
 
     def testActionsModerator(self):
     def testActionsModerator(self):
         comments = self.createSomeComments()
         comments = self.createSomeComments()
         makeModerator("normaluser")
         makeModerator("normaluser")
         self.client.login(username="normaluser", password="normaluser")
         self.client.login(username="normaluser", password="normaluser")
-        response = self.client.get("/admin/comments/comment/")
+        response = self.client.get("/admin/django_comments/comment/")
         self.assertContains(response, "approve_comments")
         self.assertContains(response, "approve_comments")
 
 
     def testActionsDisabledDelete(self):
     def testActionsDisabledDelete(self):
         "Tests a CommentAdmin where 'delete_selected' has been disabled."
         "Tests a CommentAdmin where 'delete_selected' has been disabled."
         comments = self.createSomeComments()
         comments = self.createSomeComments()
         self.client.login(username="normaluser", password="normaluser")
         self.client.login(username="normaluser", password="normaluser")
-        response = self.client.get('/admin2/comments/comment/')
+        response = self.client.get('/admin2/django_comments/comment/')
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.status_code, 200)
         self.assertNotContains(response, '<option value="delete_selected">')
         self.assertNotContains(response, '<option value="delete_selected">')
 
 
     def performActionAndCheckMessage(self, action, action_params, expected_message):
     def performActionAndCheckMessage(self, action, action_params, expected_message):
-        response = self.client.post('/admin/comments/comment/',
+        response = self.client.post('/admin/django_comments/comment/',
                                     data={'_selected_action': action_params,
                                     data={'_selected_action': action_params,
                                           'action': action,
                                           'action': action,
                                           'index': 0},
                                           'index': 0},
                                     follow=True)
                                     follow=True)
-        self.assertContains(response, expected_message)
+        messages = list(m.message for m in response.context['messages'])
+        self.assert_(expected_message in messages,
+                     ("Expected message '%s' wasn't set (messages were: %s)" %
+                        (expected_message, messages)))
 
 
     def testActionsMessageTranslations(self):
     def testActionsMessageTranslations(self):
         c1, c2, c3, c4 = self.createSomeComments()
         c1, c2, c3, c4 = self.createSomeComments()
@@ -306,11 +309,11 @@ class AdminActionsTests(CommentTestCase):
         self.client.login(username="normaluser", password="normaluser")
         self.client.login(username="normaluser", password="normaluser")
         with translation.override('en'):
         with translation.override('en'):
             #Test approving
             #Test approving
-            self.performActionAndCheckMessage('approve_comments', one_comment, '1 comment was successfully approved')
-            self.performActionAndCheckMessage('approve_comments', many_comments, '3 comments were successfully approved')
+            self.performActionAndCheckMessage('approve_comments', one_comment, '1 comment was successfully approved.')
+            self.performActionAndCheckMessage('approve_comments', many_comments, '3 comments were successfully approved.')
             #Test flagging
             #Test flagging
-            self.performActionAndCheckMessage('flag_comments', one_comment, '1 comment was successfully flagged')
-            self.performActionAndCheckMessage('flag_comments', many_comments, '3 comments were successfully flagged')
+            self.performActionAndCheckMessage('flag_comments', one_comment, '1 comment was successfully flagged.')
+            self.performActionAndCheckMessage('flag_comments', many_comments, '3 comments were successfully flagged.')
             #Test removing
             #Test removing
-            self.performActionAndCheckMessage('remove_comments', one_comment, '1 comment was successfully removed')
-            self.performActionAndCheckMessage('remove_comments', many_comments, '3 comments were successfully removed')
+            self.performActionAndCheckMessage('remove_comments', one_comment, '1 comment was successfully removed.')
+            self.performActionAndCheckMessage('remove_comments', many_comments, '3 comments were successfully removed.')

@@ -4,7 +4,7 @@ from django.conf.urls import patterns, url
 
 
 from django_comments.feeds import LatestCommentFeed
 from django_comments.feeds import LatestCommentFeed
 
 
-from .custom_comments import views
+from custom_comments import views
 
 
 
 
 feeds = {
 feeds = {