Python signals.connect_discussion_signals函数代码示例

 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": "[email protected]", "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_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):
        # 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": "[email protected]", "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_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_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': '[email protected]',
                 '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):
     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_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': '[email protected]',
                 '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

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()