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 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:%s@%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 __init__(self, *args, **kwargs): super(Command, self).__init__(*args, **kwargs) 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() self.site = Site.objects.get_current() self.author = Author.objects.create_user(username='******', email='*****@*****.**', 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() self.site = Site.objects.get_current() self.author = Author.objects.create_user(username='******', email='*****@*****.**', 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 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 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 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_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 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="******", email="*****@*****.**") 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() # 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='******', email='*****@*****.**') 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() # 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='******', email='*****@*****.**') 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='******', first_name='Root', last_name='Bloody', email='*****@*****.**') self.category = Category.objects.create(title='Tests', slug='tests') self.entry_ct_id = ContentType.objects.get_for_model(Entry).pk
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_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='******', email='*****@*****.**') 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='******', email='*****@*****.**') 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 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="******", email="*****@*****.**") 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_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() 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='******', email='*****@*****.**') 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": "*****@*****.**", "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': '*****@*****.**', '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_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)
def setUp(self): disconnect_entry_signals() disconnect_discussion_signals() params = {'title': 'My entry', 'status': PUBLISHED, 'slug': 'my-entry'} self.entry = Entry.objects.create(**params) self.site = Site.objects.get_current()
"""Suite of TestCases for Django""" suite = TestSuite() loader = TestLoader() test_cases = (ManagersTestCase, EntryTestCase, LoadModelClassTestCase, SignalsTestCase, EntryHtmlContentTestCase, CategoryTestCase, ZinniaViewsTestCase, ZinniaFeedsTestCase, ZinniaSitemapsTestCase, ComparisonTestCase, DirectoryPingerTestCase, ExternalUrlsPingerTestCase, TemplateTagsTestCase, QuickEntryTestCase, URLShortenerTestCase, EntryCommentModeratorTestCase, ZinniaCustomDetailViews, SpamCheckerTestCase, EntryAdminTestCase, CategoryAdminTestCase, MixinTestCase, LongEnoughTestCase, AuthorTestCase, FlagsTestCase, AuthorListFilterTestCase, CategoryListFilterTestCase, TranslatedURLsTestCase, EntryAbsoluteUrlTestCase) if 'django_xmlrpc' in settings.INSTALLED_APPS: test_cases += (PingBackTestCase, MetaWeblogTestCase) for test_class in test_cases: tests = loader.loadTestsFromTestCase(test_class) suite.addTests(tests) return suite disconnect_entry_signals() disconnect_discussion_signals()
def setUp(self): disconnect_entry_signals() disconnect_discussion_signals()
def suite(): """Suite of TestCases for Django""" suite = TestSuite() loader = TestLoader() test_cases = (ManagersTestCase, EntryTestCase, LoadModelClassTestCase, SignalsTestCase, EntryHtmlContentTestCase, CategoryTestCase, ZinniaViewsTestCase, ZinniaFeedsTestCase, ZinniaSitemapsTestCase, ComparisonTestCase, DirectoryPingerTestCase, ExternalUrlsPingerTestCase, TemplateTagsTestCase, QuickEntryTestCase, URLShortenerTestCase, EntryCommentModeratorTestCase, ZinniaCustomDetailViews, SpamCheckerTestCase, EntryAdminTestCase, CategoryAdminTestCase, MixinTestCase, LongEnoughTestCase, AuthorTestCase, FlagsTestCase, AuthorListFilterTestCase, CategoryListFilterTestCase, TranslatedURLsTestCase, EntryAbsoluteUrlTestCase) if 'django_xmlrpc' in settings.INSTALLED_APPS: test_cases += (PingBackTestCase, MetaWeblogTestCase) for test_class in test_cases: tests = loader.loadTestsFromTestCase(test_class) suite.addTests(tests) return suite disconnect_entry_signals() disconnect_discussion_signals()