def test_integrity_error_on_duplicate_spam_comments(self):
class AllIsSpamModerator(EntryCommentModerator):
spam_checker_backends = [
'events.spam_checker.backends.all_is_spam'
]
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, AllIsSpamModerator)
datas = {
'name': 'Jim Bob',
'email': '*****@*****.**',
'url': '',
'comment': 'This is my comment'
}
f = CommentForm(self.entry)
datas.update(f.initial)
url = reverse('comments-post-comment')
self.assertEqual(self.entry.comment_count, 0)
connect_discussion_signals()
self.client.post(url, datas)
self.client.post(url, datas)
disconnect_discussion_signals()
self.assertEqual(comments.get_model().objects.count(), 1)
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEqual(entry_reloaded.comment_count, 0)
def test_pingback_ping(self):
target = 'http://%s%s' % (
self.site.domain, self.first_entry.get_absolute_url())
source = 'http://%s%s' % (
self.site.domain, self.second_entry.get_absolute_url())
# Error code 0 : A generic fault code
response = self.server.pingback.ping('toto', 'titi')
self.assertEqual(response, 0)
response = self.server.pingback.ping('http://%s/' % self.site.domain,
'http://%s/' % self.site.domain)
self.assertEqual(response, 0)
# Error code 16 : The source URI does not exist.
response = self.server.pingback.ping('http://external/', target)
self.assertEqual(response, 16)
# Error code 17 : The source URI does not contain a link to
# the target URI and so cannot be used as a source.
response = self.server.pingback.ping(source, 'toto')
self.assertEqual(response, 17)
# Error code 32 : The target URI does not exist.
response = self.server.pingback.ping(
source, 'http://example.com/error-404/')
self.assertEqual(response, 32)
response = self.server.pingback.ping(source, 'http://external/')
self.assertEqual(response, 32)
# Error code 33 : The target URI cannot be used as a target.
response = self.server.pingback.ping(source, 'http://example.com/')
self.assertEqual(response, 33)
self.first_entry.pingback_enabled = False
self.first_entry.save()
response = self.server.pingback.ping(source, target)
self.assertEqual(response, 33)
# Validate pingback
self.assertEqual(self.first_entry.pingback_count, 0)
self.first_entry.pingback_enabled = True
self.first_entry.save()
connect_discussion_signals()
response = self.server.pingback.ping(source, target)
disconnect_discussion_signals()
self.assertEqual(
response,
'Pingback from %s to %s registered.' % (source, target))
first_entry_reloaded = Entry.objects.get(pk=self.first_entry.pk)
self.assertEqual(first_entry_reloaded.pingback_count, 1)
self.assertTrue(self.second_entry.title in
self.first_entry.pingbacks[0].user_name)
# Error code 48 : The pingback has already been registered.
response = self.server.pingback.ping(source, target)
self.assertEqual(response, 48)
def test_pingback_ping_on_entry_without_author(self):
target = 'http://%s%s' % (
self.site.domain, self.first_entry.get_absolute_url())
source = 'http://%s%s' % (
self.site.domain, self.second_entry.get_absolute_url())
self.first_entry.pingback_enabled = True
self.first_entry.save()
self.first_entry.authors.clear()
connect_discussion_signals()
response = self.server.pingback.ping(source, target)
disconnect_discussion_signals()
self.assertEqual(
response,
'Pingback from %s to %s registered.' % (source, target))
first_entry_reloaded = Entry.objects.get(pk=self.first_entry.pk)
self.assertEqual(first_entry_reloaded.pingback_count, 1)
self.assertTrue(self.second_entry.title in
self.first_entry.pingbacks[0].user_name)
def test_comment_count_denormalization(self):
class AllIsSpamModerator(EntryCommentModerator):
spam_checker_backends = [
'events.spam_checker.backends.all_is_spam'
]
class NoMailNoSpamModerator(EntryCommentModerator):
def email(self, *ka, **kw):
pass
def moderate(self, *ka, **kw):
return False
datas = {
'name': 'Jim Bob',
'email': '*****@*****.**',
'url': '',
'comment': 'This is my comment'
}
f = CommentForm(self.entry)
datas.update(f.initial)
url = reverse('comments-post-comment')
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, AllIsSpamModerator)
self.assertEqual(self.entry.comment_count, 0)
connect_discussion_signals()
self.client.post(url, datas)
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEqual(entry_reloaded.comment_count, 0)
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, NoMailNoSpamModerator)
datas['comment'] = 'This a published comment'
self.client.post(url, datas)
disconnect_discussion_signals()
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEqual(entry_reloaded.comment_count, 1)
def test_zinnia_trackback(self):
# Clean the memoization of user flagger to avoid error on MySQL
try:
del user_flagger_[()]
except KeyError:
pass
self.inhibit_templates('events/entry_trackback.xml', '404.html')
response = self.client.post('/trackback/404/')
trackback_url = '/trackback/%s/' % self.first_entry.pk
self.assertEqual(response.status_code, 404)
self.assertEqual(self.client.post(trackback_url).status_code, 301)
self.first_entry.trackback_enabled = False
self.first_entry.save()
self.assertEqual(self.first_entry.trackback_count, 0)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual(response.context['error'],
'Trackback is not enabled for Test 1')
self.first_entry.trackback_enabled = True
self.first_entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
if comments.get_comment_app_name() == comments.DEFAULT_COMMENTS_APP:
# If we are using the default comment app,
# we can count the database queries executed.
with self.assertNumQueries(8):
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
else:
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual('error' in response.context, False)
disconnect_discussion_signals()
entry = Entry.objects.get(pk=self.first_entry.pk)
self.assertEqual(entry.trackback_count, 1)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response.context['error'],
'Trackback is already registered')
"""Models for Zinnia"""
from django_comments.moderation import moderator
from events.models.entry import Entry
from events.models.author import Author
from events.models.category import Category
from events.signals import connect_entry_signals
from events.signals import connect_discussion_signals
from events.moderator import EntryCommentModerator
# Here we import the Zinnia's Model classes
# to register the Models at the loading, not
# when the Zinnia's URLs are parsed. Issue #161.
__all__ = [Entry.__name__, Author.__name__, Category.__name__]
# Register the comment moderator on Entry
if Entry not in moderator._registry:
moderator.register(Entry, EntryCommentModerator)
# Connect the signals
connect_entry_signals()
connect_discussion_signals()