def setUp(self):
     disconnect_entry_signals()
     disconnect_discussion_signals()
     params = {'title': 'My entry',
               'content': 'My content',
               'slug': 'my-entry'}
     self.entry = Entry.objects.create(**params)

    def handle(self, database_name, **options):

        # Verify that
        if options['threaded_comments'] and not hasattr(Comment, "parent"):
            raise CommandError("Currently configured comment model does not have the 'parent' attribute, but threaded comment import has been requested. Check your COMMENTS_APP setting.")

        # Read the password for Drupal database if it wasn't provided within a file.
        if options['database_password_file']:
            options['database_password'] = open(options['database_password_file'], "r").read().rstrip().lstrip()
        else:
            options['database_password'] = getpass.getpass("Database password for '%s'@'%s': " % (options['database_username'], database_name))

        # Set-up SQLAlchemy ORM.
        database_connection_url = "mysql://%s:%[email protected]%s/%s" % (urllib.quote(options['database_username']),
                                                           urllib.quote(options['database_password']),
                                                           urllib.quote(options['database_hostname']),
                                                           urllib.quote(database_name))
        engine = create_engine(database_connection_url)
        drupal = DrupalDatabase(engine)

        # Create list of users that should be imported.
        users = options["users"]
        if users:
            users = users.split(",")

        # Disconnect Zinnia signals.
        disconnect_discussion_signals()
        disconnect_entry_signals()

        # Import the users.
        with transaction.atomic():
            user_stats, user_mapping = import_users(drupal, users=users, custom_mapping=options["user_mapping"])
        # Import the categories.
        with transaction.atomic():
            category_stats, category_mapping = import_categories(drupal)
        # Extract the tag mapping.
        with transaction.atomic():
            tag_mapping = extract_tags(drupal)
        # Finally, import the actual content.
        with transaction.atomic():
            content_stats = import_content(drupal, user_mapping, category_mapping, tag_mapping, options['node_type'], options["threaded_comments"])

        # Output a summary.
        print
        print "User import summary"
        print "==================="
        for key, value in user_stats.iteritems():
            print "%s: %s" % (key, value)

        print
        print "Category import summary"
        print "======================="
        for key, value in category_stats.iteritems():
            print "%s: %s" % (key, value)

        print
        print "Content import summary"
        print "======================"
        for key, value in content_stats.iteritems():
            print "%s: %s" % (key, value)

 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 setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        self.site = Site.objects.get_current()
        self.author = Author.objects.create_user(username='admin',
                                                 email='[email protected]',
                                                 password='password')
        self.category = Category.objects.create(title='Tests', slug='tests')
        params = {'title': 'Test 1',
                  'content': 'First test entry published',
                  'slug': 'test-1',
                  'tags': 'tests',
                  'publication_date': datetime(2010, 1, 1, 23, 0),
                  'status': PUBLISHED}
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)
        self.first_entry = entry

        params = {'title': 'Test 2',
                  'content': 'Second test entry published',
                  'slug': 'test-2',
                  'tags': 'tests',
                  'publication_date': datetime(2010, 5, 31, 23, 00),
                  'status': PUBLISHED}
        entry = Entry.objects.create(**params)
        entry.sites.add(self.site)
        entry.categories.add(self.category)
        entry.authors.add(self.author)
        self.second_entry = entry

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        # Clear the cache of user flagger to avoid error on MySQL
        get_user_flagger.cache_clear()
        # Use default URL shortener backend, to avoid networks errors
        self.original_shortener = shortener_settings.URL_SHORTENER_BACKEND
        shortener_settings.URL_SHORTENER_BACKEND = "zinnia.url_shortener." "backends.default"
        # Set up a stub around urlopen
        import zinnia.xmlrpc.pingback

        self.original_urlopen = zinnia.xmlrpc.pingback.urlopen
        zinnia.xmlrpc.pingback.urlopen = self.fake_urlopen
        # Set a short template for entry_detail to avoid rendering errors
        setup_test_template_loader(
            {
                "zinnia/entry_detail.html": "<html><head><title>{{ object.title }}</title></head>"
                "<body>{{ object.html_content|safe }}</body></html>",
                "404.html": "404",
            }
        )
        # Preparing site
        self.site = Site.objects.get_current()
        # Creating tests entries
        self.author = Author.objects.create_user(username="webmaster", email="[email protected]")
        self.category = Category.objects.create(title="test", slug="test")
        params = {
            "title": "My first entry",
            "content": "My first content",
            "slug": "my-first-entry",
            "creation_date": datetime(2010, 1, 1, 12),
            "status": PUBLISHED,
        }
        self.first_entry = Entry.objects.create(**params)
        self.first_entry.sites.add(self.site)
        self.first_entry.categories.add(self.category)
        self.first_entry.authors.add(self.author)

        params = {
            "title": "My second entry",
            "content": "My second content with link "
            'to <a href="http://%s%s">first entry</a>'
            " and other links : %s %s."
            % (
                self.site.domain,
                self.first_entry.get_absolute_url(),
                "http://example.com/error-404/",
                "http://external/",
            ),
            "slug": "my-second-entry",
            "creation_date": datetime(2010, 1, 1, 12),
            "status": PUBLISHED,
        }
        self.second_entry = Entry.objects.create(**params)
        self.second_entry.sites.add(self.site)
        self.second_entry.categories.add(self.category)
        self.second_entry.authors.add(self.author)
        # Instanciating the server proxy
        self.server = ServerProxy("http://example.com/xmlrpc/", transport=TestTransport())

 def __init__(self):
     """Init the Command and add custom styles"""
     super(Command, self).__init__()
     self.style.TITLE = self.style.SQL_FIELD
     self.style.STEP = self.style.SQL_COLTYPE
     self.style.ITEM = self.style.HTTP_INFO
     disconnect_entry_signals()
     disconnect_discussion_signals()

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        # Clean the memoization of user flagger to avoid error on MySQL
        try:
            del user_flagger_[()]
        except KeyError:
            pass
        # Use default URL shortener backend, to avoid networks errors
        self.original_shortener = shortener_settings.URL_SHORTENER_BACKEND
        shortener_settings.URL_SHORTENER_BACKEND = 'zinnia.url_shortener.'\
                                                   'backends.default'
        # Set up a stub around urlopen
        import zinnia.xmlrpc.pingback
        self.original_urlopen = zinnia.xmlrpc.pingback.urlopen
        zinnia.xmlrpc.pingback.urlopen = self.fake_urlopen
        # Set a short template for entry_detail to avoid rendering errors
        setup_test_template_loader(
            {'zinnia/entry_detail.html':
             '<html><head><title>{{ object.title }}</title></head>'
             '<body>{{ object.html_content|safe }}</body></html>',
             '404.html': '404'})
        # Preparing site
        self.site = Site.objects.get_current()
        # Creating tests entries
        self.author = Author.objects.create_user(username='webmaster',
                                                 email='[email protected]')
        self.category = Category.objects.create(title='test', slug='test')
        params = {'title': 'My first entry',
                  'content': 'My first content',
                  'slug': 'my-first-entry',
                  'creation_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.first_entry = Entry.objects.create(**params)
        self.first_entry.sites.add(self.site)
        self.first_entry.categories.add(self.category)
        self.first_entry.authors.add(self.author)

        params = {'title': 'My second entry',
                  'content': 'My second content with link '
                  'to <a href="http://%s%s">first entry</a>'
                  ' and other links : %s %s.' % (
                      self.site.domain,
                      self.first_entry.get_absolute_url(),
                      'http://example.com/error-404/',
                      'http://external/'),
                  'slug': 'my-second-entry',
                  'creation_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.second_entry = Entry.objects.create(**params)
        self.second_entry.sites.add(self.site)
        self.second_entry.categories.add(self.category)
        self.second_entry.authors.add(self.author)
        # Instanciating the server proxy
        self.server = ServerProxy('http://example.com/xmlrpc/',
                                  transport=TestTransport())

 def setUp(self):
     disconnect_entry_signals()
     disconnect_discussion_signals()
     params = {'title': 'My entry',
               'content': 'My content',
               'tags': 'zinnia, test',
               'creation_date': datetime(2010, 1, 1, 12),
               'slug': 'my-entry'}
     self.entry = Entry.objects.create(**params)
     self.site = Site.objects.get_current()

    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 setUp(self):
     disconnect_entry_signals()
     disconnect_discussion_signals()
     activate('en')
     self.site = Site.objects.get_current()
     self.author = Author.objects.create(username='admin',
                                         first_name='Root',
                                         last_name='Bloody',
                                         email='[email protected]')
     self.category = Category.objects.create(title='Tests', slug='tests')
     self.entry_ct_id = ContentType.objects.get_for_model(Entry).pk

 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 setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        # Clear the cache of user flagger to avoid error on MySQL
        get_user_flagger.cache_clear()
        # Use default URL shortener backend, to avoid networks errors
        self.original_shortener = shortener_settings.URL_SHORTENER_BACKEND
        shortener_settings.URL_SHORTENER_BACKEND = 'zinnia.url_shortener.'\
                                                   'backends.default'
        # Set up a stub around urlopen
        import zinnia.xmlrpc.pingback
        self.original_urlopen = zinnia.xmlrpc.pingback.urlopen
        zinnia.xmlrpc.pingback.urlopen = self.fake_urlopen
        # Set up a stub around zinnia.spam_checker
        import zinnia.spam_checker
        self.original_scb = zinnia.spam_checker.SPAM_CHECKER_BACKENDS
        zinnia.spam_checker.SPAM_CHECKER_BACKENDS = []
        # Preparing site
        self.site = Site.objects.get_current()
        # Creating tests entries
        self.author = Author.objects.create_user(username='webmaster',
                                                 email='[email protected]')
        self.category = Category.objects.create(title='test', slug='test')
        params = {'title': 'My first entry',
                  'content': 'My first content',
                  'slug': 'my-first-entry',
                  'publication_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.first_entry = Entry.objects.create(**params)
        self.first_entry.sites.add(self.site)
        self.first_entry.categories.add(self.category)
        self.first_entry.authors.add(self.author)

        params = {'title': 'My second entry',
                  'content': 'My second content with link '
                  'to <a href="http://%s%s">first entry</a>'
                  ' and other links : %s %s.' % (
                      self.site.domain,
                      self.first_entry.get_absolute_url(),
                      'http://example.com/error-404/',
                      'http://external/'),
                  'slug': 'my-second-entry',
                  'publication_date': datetime(2010, 1, 1, 12),
                  'status': PUBLISHED}
        self.second_entry = Entry.objects.create(**params)
        self.second_entry.sites.add(self.site)
        self.second_entry.categories.add(self.category)
        self.second_entry.authors.add(self.author)
        # Instanciating the server proxy
        self.server = ServerProxy('http://example.com/xmlrpc/',
                                  transport=TestTransport())

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()

        self.site = Site.objects.get_current()
        self.author = Author.objects.create(username='admin',
                                            email='[email protected]')
        params = {'title': 'My test entry',
                  'content': 'My test entry',
                  'slug': 'my-test-entry',
                  'status': PUBLISHED}
        self.entry = Entry.objects.create(**params)
        self.entry.sites.add(self.site)
        self.entry.authors.add(self.author)

 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 setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        setup_test_template_loader(
            {
                "comments/comment_authors_email.txt": "",
                "comments/comment_notification_email.txt": "",
                "comments/comment_reply_email.txt": "",
            }
        )

        self.site = Site.objects.get_current()
        self.author = Author.objects.create(username="admin", email="[email protected]")
        params = {"title": "My test entry", "content": "My test entry", "slug": "my-test-entry", "status": PUBLISHED}
        self.entry = Entry.objects.create(**params)
        self.entry.sites.add(self.site)
        self.entry.authors.add(self.author)

    def setUp(self):
        disconnect_entry_signals()
        disconnect_discussion_signals()
        setup_test_template_loader(
            {'comments/comment_authors_email.txt': '',
             'comments/comment_notification_email.txt': '',
             'comments/comment_reply_email.txt': ''})

        self.site = Site.objects.get_current()
        self.author = Author.objects.create(username='admin',
                                            email='[email protected]')
        params = {'title': 'My test entry',
                  'content': 'My test entry',
                  'slug': 'my-test-entry',
                  'status': PUBLISHED}
        self.entry = Entry.objects.create(**params)
        self.entry.sites.add(self.site)
        self.entry.authors.add(self.author)

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