def test_zinnia_trackback(self): setup_test_template_loader({"404.html": ""}) response = self.client.post("/trackback/404/") self.assertEquals(response.status_code, 404) restore_template_loaders() self.assertEquals(self.client.post("/trackback/1/").status_code, 301) self.assertEquals(self.client.get("/trackback/1/").status_code, 301) entry = Entry.objects.get(slug="test-1") self.assertEquals(entry.trackback_count, 0) entry.trackback_enabled = False entry.save() self.assertEquals( self.client.post("/trackback/1/", {"url": "http://example.com"}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' "<error>1</error>\n <message>Trackback is not enabled for " "Test 1</message>\n \n</response>\n", ) entry.trackback_enabled = True entry.save() connect_discussion_signals() get_user_flagger() # Memoize user flagger for stable query number with self.assertNumQueries(6): self.assertEquals( self.client.post("/trackback/1/", {"url": "http://example.com"}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' "<error>0</error>\n \n</response>\n", ) disconnect_discussion_signals() entry = Entry.objects.get(pk=entry.pk) self.assertEquals(entry.trackback_count, 1) self.assertEquals( self.client.post("/trackback/1/", {"url": "http://example.com"}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' "<error>1</error>\n <message>Trackback is already registered" "</message>\n \n</response>\n", )
def test_comment_count_denormalization(self): class AllIsSpamModerator(EntryCommentModerator): spam_checker_backends = ["zinnia.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_integrity_error_on_duplicate_spam_comments(self): class AllIsSpamModerator(EntryCommentModerator): spam_checker_backends = [ 'zinnia.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_count_after_deletion_issue_283(self): comment_klass = comments.get_model() connect_discussion_signals() comment_klass.objects.create(comment='My Comment 1', site=self.site, content_object=self.entry, submit_date=timezone.now()) comment_klass.objects.create(comment='My Comment 2', site=self.site, content_object=self.entry, submit_date=timezone.now()) # It's normal, the signals are not catched on the creation self.assertEqual(self.entry.comment_count, 0) self.entry.comment_count = 2 self.entry.save() comment_klass.objects.all().delete() self.assertEqual(comment_klass.objects.count(), 0) entry_reloaded = Entry.objects.get(pk=self.entry.pk) self.assertEqual(entry_reloaded.comment_count, 0) disconnect_discussion_signals()
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://example.com/', 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://localhost:8000/error-404/') self.assertEqual(response, 32) response = self.server.pingback.ping(source, 'http://example.com/') self.assertEqual(response, 32) # Error code 33 : The target URI cannot be used as a target. response = self.server.pingback.ping(source, 'http://localhost:8000/') 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 ready(self): from django_comments.moderation import moderator from zinnia.signals import connect_entry_signals from zinnia.signals import connect_discussion_signals from zinnia.moderator import EntryCommentModerator entry_klass = self.get_model('Entry') # Register the comment moderator on Entry moderator.register(entry_klass, EntryCommentModerator) # Connect the signals connect_entry_signals() connect_discussion_signals()
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_zinnia_trackback(self): setup_test_template_loader({'404.html': ''}) response = self.client.post('/trackback/404/') self.assertEquals(response.status_code, 404) restore_template_loaders() self.assertEquals(self.client.post('/trackback/1/').status_code, 301) self.assertEquals(self.client.get('/trackback/1/').status_code, 301) entry = Entry.objects.get(slug='test-1') self.assertEquals(entry.trackback_count, 0) entry.trackback_enabled = False entry.save() self.assertEquals( self.client.post('/trackback/1/', { 'url': 'http://example.com' }).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>1</error>\n <message>Trackback is not enabled for ' 'Test 1</message>\n \n</response>\n') entry.trackback_enabled = True 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 not using the default comment app, # we can count the database queries executed. with self.assertNumQueries(6): self.assertEquals( self.client.post('/trackback/1/', { 'url': 'http://example.com' }).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>0</error>\n \n</response>\n') else: self.assertEquals( self.client.post('/trackback/1/', { 'url': 'http://example.com' }).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>0</error>\n \n</response>\n') disconnect_discussion_signals() entry = Entry.objects.get(pk=entry.pk) self.assertEquals(entry.trackback_count, 1) self.assertEquals( self.client.post('/trackback/1/', { 'url': 'http://example.com' }).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>1</error>\n <message>Trackback is already registered' '</message>\n \n</response>\n')
def test_zinnia_trackback(self): setup_test_template_loader( {'404.html': ''}) response = self.client.post('/trackback/404/') self.assertEquals(response.status_code, 404) restore_template_loaders() self.assertEquals( self.client.post('/trackback/1/').status_code, 301) self.assertEquals( self.client.get('/trackback/1/').status_code, 301) entry = Entry.objects.get(slug='test-1') self.assertEquals(entry.trackback_count, 0) entry.trackback_enabled = False entry.save() self.assertEquals( self.client.post('/trackback/1/', {'url': 'http://example.com'}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>1</error>\n <message>Trackback is not enabled for ' 'Test 1</message>\n \n</response>\n') entry.trackback_enabled = True 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 not using the default comment app, # we can count the database queries executed. with self.assertNumQueries(6): self.assertEquals( self.client.post('/trackback/1/', {'url': 'http://example.com'}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n' ' <error>0</error>\n \n</response>\n') else: self.assertEquals( self.client.post('/trackback/1/', {'url': 'http://example.com'}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>0</error>\n \n</response>\n') disconnect_discussion_signals() entry = Entry.objects.get(pk=entry.pk) self.assertEquals(entry.trackback_count, 1) self.assertEquals( self.client.post('/trackback/1/', {'url': 'http://example.com'}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>1</error>\n <message>Trackback is already registered' '</message>\n \n</response>\n')
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_zinnia_trackback(self): # Clear the cache of user flagger to avoid error on MySQL get_user_flagger.cache_clear() # Disable spam-checkers import zinnia.spam_checker original_scb = zinnia.spam_checker.SPAM_CHECKER_BACKENDS zinnia.spam_checker.SPAM_CHECKER_BACKENDS = [] 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') zinnia.spam_checker.SPAM_CHECKER_BACKENDS = original_scb
def test_integrity_error_on_duplicate_spam_comments(self): class AllIsSpamModerator(EntryCommentModerator): spam_checker_backends = ["zinnia.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.assertEquals(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 = Entry.objects.get(pk=self.entry.pk) self.assertEquals(entry.comment_count, 0)
def test_comment_count_denormalization(self): class AllIsSpamModerator(EntryCommentModerator): spam_checker_backends = [ 'zinnia.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('zinnia/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')
def test_zinnia_trackback(self): setup_test_template_loader( {'404.html': ''}) response = self.client.post('/trackback/404/') self.assertEquals(response.status_code, 404) restore_template_loaders() self.assertEquals( self.client.post('/trackback/1/').status_code, 301) self.assertEquals( self.client.get('/trackback/1/').status_code, 301) entry = Entry.objects.get(slug='test-1') self.assertEquals(entry.trackback_count, 0) entry.pingback_enabled = False entry.save() self.assertEquals( self.client.post('/trackback/1/', {'url': 'http://example.com'}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>1</error>\n <message>Trackback is not enabled for ' 'Test 1</message>\n \n</response>\n') entry.pingback_enabled = True entry.save() connect_discussion_signals() with self.assertNumQueries(6): self.assertEquals( self.client.post('/trackback/1/', {'url': 'http://example.com'}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>0</error>\n \n</response>\n') disconnect_discussion_signals() entry = Entry.objects.get(pk=entry.pk) self.assertEquals(entry.trackback_count, 1) self.assertEquals( self.client.post('/trackback/1/', {'url': 'http://example.com'}).content, '<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' '<error>1</error>\n <message>Trackback is already registered' '</message>\n \n</response>\n')
def test_comment_count_denormalization(self): class AllIsSpamModerator(EntryCommentModerator): spam_checker_backends = [ 'zinnia.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): self.inhibit_templates('zinnia/entry_trackback.xml', '404.html') response = self.client.post('/trackback/404/') self.assertEquals(response.status_code, 404) self.assertEquals( self.client.post('/trackback/1/').status_code, 301) entry = Entry.objects.get(slug='test-1') entry.trackback_enabled = False entry.save() self.assertEquals(entry.trackback_count, 0) response = self.client.post('/trackback/1/', {'url': 'http://example.com'}) self.assertEquals(response['Content-Type'], 'text/xml') self.assertEquals(response.context['error'], 'Trackback is not enabled for Test 1') entry.trackback_enabled = True 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(6): response = self.client.post('/trackback/1/', {'url': 'http://example.com'}) else: response = self.client.post('/trackback/1/', {'url': 'http://example.com'}) self.assertEquals(response['Content-Type'], 'text/xml') self.assertEquals('error' in response.context, False) disconnect_discussion_signals() entry = Entry.objects.get(pk=entry.pk) self.assertEquals(entry.trackback_count, 1) response = self.client.post('/trackback/1/', {'url': 'http://example.com'}) self.assertEquals(response.context['error'], 'Trackback is already registered')
def test_integrity_error_on_duplicate_spam_comments(self): class AllIsSpamModerator(EntryCommentModerator): spam_checker_backends = [ 'zinnia.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)
"""Models for Zinnia""" from zinnia.models.entry import Entry from zinnia.models.author import Author from zinnia.models.category import Category from zinnia.signals import connect_entry_signals from zinnia.signals import connect_discussion_signals from zinnia.moderator import EntryCommentModerator from django.contrib.comments.moderation import moderator # 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 moderator.register(Entry, EntryCommentModerator) # Connect the signals connect_entry_signals() connect_discussion_signals()
"""Models for Zinnia""" from zinnia.models.entry import Entry from zinnia.models.author import Author from zinnia.models.category import Category from zinnia.signals import connect_entry_signals from zinnia.signals import connect_discussion_signals from zinnia.moderator import EntryCommentModerator try: from django_comments.moderation import moderator except ImportError: from django.contrib.comments.moderation import moderator # 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 moderator.register(Entry, EntryCommentModerator) # Connect the signals connect_entry_signals() connect_discussion_signals()