def setUp(self):
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",
"creation_date": datetime(2010, 1, 1, 13, 25),
"status": PUBLISHED,
}
entry = Entry.objects.create(**params)
entry.sites.add(self.site)
entry.categories.add(self.category)
entry.authors.add(self.author)
params = {
"title": "Test 2",
"content": "Second test entry published",
"slug": "test-2",
"tags": "tests",
"creation_date": datetime(2010, 6, 1, 12, 12),
"status": PUBLISHED,
}
entry = Entry.objects.create(**params)
entry.sites.add(self.site)
entry.categories.add(self.category)
entry.authors.add(self.author)
def setUp(self):
self.site = Site.objects.get_current()
self.author = User.objects.create_superuser(
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',
'creation_date': datetime(2010, 1, 1, 13, 25),
'status': PUBLISHED}
entry = Entry.objects.create(**params)
entry.sites.add(self.site)
entry.categories.add(self.category)
entry.authors.add(self.author)
params = {'title': 'Test 2',
'content': 'Second test entry published',
'slug': 'test-2',
'tags': 'tests',
'creation_date': datetime(2010, 6, 1, 12, 12),
'status': PUBLISHED}
entry = Entry.objects.create(**params)
entry.sites.add(self.site)
entry.categories.add(self.category)
entry.authors.add(self.author)
def test_previous_next_entry_in_one_query(self):
site = Site.objects.get_current()
self.entry.status = PUBLISHED
self.entry.save()
self.entry.sites.add(site)
with self.assertNumQueries(1):
self.assertFalse(self.entry.previous_entry)
self.assertFalse(self.entry.next_entry)
# Reload to check the cache
self.assertFalse(self.entry.previous_entry)
self.assertFalse(self.entry.next_entry)
params = {'title': 'My second entry',
'content': 'My second content',
'slug': 'my-second-entry',
'creation_date': datetime(2001, 1, 1),
'status': PUBLISHED}
self.second_entry = Entry.objects.create(**params)
self.second_entry.sites.add(site)
params = {'title': 'My third entry',
'content': 'My third content',
'slug': 'my-third-entry',
'creation_date': datetime(2050, 1, 1),
'status': PUBLISHED}
self.third_entry = Entry.objects.create(**params)
self.third_entry.sites.add(site)
del self.entry.previous_next # Invalidate the cached property
with self.assertNumQueries(1):
self.assertEqual(self.entry.previous_entry, self.second_entry)
self.assertEqual(self.entry.next_entry, self.third_entry)
# Reload to check the cache
self.assertEqual(self.entry.previous_entry, self.second_entry)
self.assertEqual(self.entry.next_entry, self.third_entry)
def setUp(self):
# Create data
self.webmaster = Author.objects.create_superuser(
username='******',
email='*****@*****.**',
password='******')
self.contributor = Author.objects.create_user(
username='******',
email='*****@*****.**',
password='******')
self.site = Site.objects.get_current()
self.categories = [
Category.objects.create(title='Category 1',
slug='category-1'),
Category.objects.create(title='Category 2',
slug='category-2')]
params = {'title': 'My entry 1', 'content': 'My content 1',
'tags': 'zinnia, test', 'slug': 'my-entry-1',
'creation_date': datetime(2010, 1, 1, 12),
'status': PUBLISHED}
self.entry_1 = Entry.objects.create(**params)
self.entry_1.authors.add(self.webmaster)
self.entry_1.categories.add(*self.categories)
self.entry_1.sites.add(self.site)
params = {'title': 'My entry 2', 'content': 'My content 2',
'creation_date': datetime(2010, 3, 15),
'tags': 'zinnia, test', 'slug': 'my-entry-2'}
self.entry_2 = Entry.objects.create(**params)
self.entry_2.authors.add(self.webmaster)
self.entry_2.categories.add(self.categories[0])
self.entry_2.sites.add(self.site)
# Instanciating the server proxy
self.server = ServerProxy('http://localhost:8000/xmlrpc/',
transport=TestTransport())
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_edit_post(self):
post = post_structure(self.entry_2, self.site)
self.assertRaises(Fault, self.server.metaWeblog.editPost,
1, 'contributor', 'password', post, 1)
new_post_id = self.server.metaWeblog.newPost(
1, 'webmaster', 'password', post, 0)
entry = Entry.objects.get(pk=new_post_id)
self.assertEqual(entry.title, self.entry_2.title)
self.assertEqual(entry.content, self.entry_2.html_content)
self.assertEqual(entry.excerpt, self.entry_2.excerpt)
self.assertEqual(entry.slug, self.entry_2.slug)
self.assertEqual(entry.status, DRAFT)
self.assertEqual(entry.password, self.entry_2.password)
self.assertEqual(entry.comment_enabled, True)
self.assertEqual(entry.pingback_enabled, True)
self.assertEqual(entry.categories.count(), 1)
self.assertEqual(entry.authors.count(), 1)
self.assertEqual(entry.authors.all()[0], self.webmaster)
self.assertEqual(entry.creation_date, self.entry_2.creation_date)
self.assertEqual(entry.publication_date, self.entry_2.creation_date)
entry.title = 'Title edited'
entry.creation_date = datetime(2000, 1, 1)
post = post_structure(entry, self.site)
post['categories'] = ''
post['description'] = 'Content edited'
post['mt_excerpt'] = 'Content edited'
post['wp_slug'] = 'slug-edited'
post['wp_password'] = '******'
post['mt_allow_comments'] = 2
post['mt_allow_pings'] = 0
response = self.server.metaWeblog.editPost(
new_post_id, 'webmaster', 'password', post, 1)
self.assertEqual(response, True)
entry = Entry.objects.get(pk=new_post_id)
self.assertEqual(entry.title, post['title'])
self.assertEqual(entry.content, post['description'])
self.assertEqual(entry.excerpt, post['mt_excerpt'])
self.assertEqual(entry.slug, 'slug-edited')
self.assertEqual(entry.status, PUBLISHED)
self.assertEqual(entry.password, 'password')
self.assertEqual(entry.comment_enabled, False)
self.assertEqual(entry.pingback_enabled, False)
self.assertEqual(entry.categories.count(), 0)
self.assertEqual(entry.creation_date, datetime(2000, 1, 1))
self.assertEqual(entry.publication_date, datetime(2000, 1, 1))
del post['dateCreated']
post['wp_author_id'] = self.contributor.pk
response = self.server.metaWeblog.editPost(
new_post_id, 'webmaster', 'password', post, 1)
entry = Entry.objects.get(pk=new_post_id)
self.assertEqual(entry.authors.count(), 1)
self.assertEqual(entry.authors.all()[0], self.contributor)
self.assertEqual(entry.creation_date, datetime(2000, 1, 1))
self.assertEqual(entry.publication_date, datetime(2000, 1, 1))
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 test_is_actual(self):
self.assertTrue(self.entry.is_actual)
self.entry.start_publication = datetime(2020, 3, 15)
self.assertFalse(self.entry.is_actual)
self.entry.start_publication = timezone.now()
self.assertTrue(self.entry.is_actual)
self.entry.end_publication = datetime(2000, 3, 15)
self.assertFalse(self.entry.is_actual)
def test_archives_entries_tree_with_timezone(self):
template = Template('{% load zinnia %}'
'{% get_archives_entries_tree %}')
self.create_published_entry_at(datetime(2014, 1, 1, 12, 0))
self.create_published_entry_at(datetime(2014, 1, 31, 23, 0))
output = template.render(Context())
self.assertTrue('/2014/01/01/' in output)
self.assertTrue('/2014/02/01/' in output)
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 test_calendar_entries_no_timezone(self):
template = Template('{% load zinnia %}'
'{% get_calendar_entries 2014 1 %}')
self.create_published_entry_at(datetime(2014, 1, 1, 12, 0))
self.create_published_entry_at(datetime(2014, 1, 1, 23, 0))
self.create_published_entry_at(datetime(2012, 12, 31, 23, 0))
self.create_published_entry_at(datetime(2014, 1, 31, 23, 0))
output = template.render(Context())
self.assertTrue('/2014/01/01/' in output)
self.assertTrue('/2014/01/02/' not in output)
self.assertTrue('/2012/12/' in output)
self.assertTrue('/2014/02/' not in output)
def test_edit_post(self):
post = post_structure(self.entry_2, self.site)
self.assertRaises(Fault, self.server.metaWeblog.editPost, 1, "contributor", "password", post, 1)
new_post_id = self.server.metaWeblog.newPost(1, "webmaster", "password", post, 0)
entry = Entry.objects.get(pk=new_post_id)
self.assertEqual(entry.title, self.entry_2.title)
self.assertEqual(entry.content, self.entry_2.html_content)
self.assertEqual(entry.excerpt, self.entry_2.excerpt)
self.assertEqual(entry.slug, self.entry_2.slug)
self.assertEqual(entry.status, DRAFT)
self.assertEqual(entry.password, self.entry_2.password)
self.assertEqual(entry.comment_enabled, True)
self.assertEqual(entry.pingback_enabled, True)
self.assertEqual(entry.categories.count(), 1)
self.assertEqual(entry.authors.count(), 1)
self.assertEqual(entry.authors.all()[0], self.webmaster)
self.assertEqual(entry.creation_date, self.entry_2.creation_date)
entry.title = "Title edited"
entry.creation_date = datetime(2000, 1, 1)
post = post_structure(entry, self.site)
post["categories"] = ""
post["description"] = "Content edited"
post["mt_excerpt"] = "Content edited"
post["wp_slug"] = "slug-edited"
post["wp_password"] = "******"
post["mt_allow_comments"] = 2
post["mt_allow_pings"] = 0
response = self.server.metaWeblog.editPost(new_post_id, "webmaster", "password", post, 1)
self.assertEqual(response, True)
entry = Entry.objects.get(pk=new_post_id)
self.assertEqual(entry.title, post["title"])
self.assertEqual(entry.content, post["description"])
self.assertEqual(entry.excerpt, post["mt_excerpt"])
self.assertEqual(entry.slug, "slug-edited")
self.assertEqual(entry.status, PUBLISHED)
self.assertEqual(entry.password, "password")
self.assertEqual(entry.comment_enabled, False)
self.assertEqual(entry.pingback_enabled, False)
self.assertEqual(entry.categories.count(), 0)
self.assertEqual(entry.creation_date, datetime(2000, 1, 1))
del post["dateCreated"]
post["wp_author_id"] = self.contributor.pk
response = self.server.metaWeblog.editPost(new_post_id, "webmaster", "password", post, 1)
entry = Entry.objects.get(pk=new_post_id)
self.assertEqual(entry.authors.count(), 1)
self.assertEqual(entry.authors.all()[0], self.contributor)
self.assertEqual(entry.creation_date, datetime(2000, 1, 1))
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 test_zinnia_entry_archive_month_with_timezone(self):
response = self.check_publishing_context(
'/2010/01/', 1, 2, 'entry_list', 3)
self.assertTemplateUsed(
response, 'zinnia/archives/2010/month/01/entry_archive_month.html')
self.assertEqual(response.context['previous_month'], None)
self.assertEqual(response.context['next_month'], date(2010, 6, 1))
self.assertEqual(response.context['date_list'][0].date(),
datetime(2010, 1, 2).date())
response = self.client.get('/2010/06/')
self.assertEqual(response.context['previous_month'], date(2010, 1, 1))
self.assertEqual(response.context['next_month'], None)
self.assertEqual(response.context['date_list'][0].date(),
datetime(2010, 6, 1).date())
def test_discussion_feed_with_same_slugs(self):
"""
https://github.com/Fantomas42/django-blog-zinnia/issues/104
OK, Here I will reproduce the original case: getting a discussion
type feed, with a same slug.
The correction of this case, will need some changes in the
get_object method.
"""
entry = self.create_published_entry()
feed = EntryDiscussions()
self.assertEqual(feed.get_object("request", 2010, 1, 1, entry.slug), entry)
params = {
"title": "My test entry, part II",
"content": "My content ",
"slug": "my-test-entry",
"tags": "tests",
"creation_date": datetime(2010, 2, 1, 12),
"status": PUBLISHED,
}
entry_same_slug = Entry.objects.create(**params)
entry_same_slug.sites.add(self.site)
entry_same_slug.authors.add(self.author)
self.assertEqual(feed.get_object("request", 2010, 2, 1, entry_same_slug.slug), entry_same_slug)
def test_get_archives_tree(self):
with self.assertNumQueries(0):
context = get_archives_entries_tree()
self.assertEqual(len(context['archives']), 0)
self.assertEqual(context['template'],
'zinnia/tags/entries_archives_tree.html')
self.publish_entry()
params = {'title': 'My second entry',
'content': 'My second content',
'tags': 'zinnia, test',
'status': PUBLISHED,
'creation_date': datetime(2009, 1, 10),
'slug': 'my-second-entry'}
second_entry = Entry.objects.create(**params)
second_entry.sites.add(self.site)
with self.assertNumQueries(0):
context = get_archives_entries_tree('custom_template.html')
self.assertEqual(len(context['archives']), 2)
self.assertEqual(
context['archives'][0],
self.make_local(
second_entry.creation_date).replace(hour=0))
self.assertEqual(
context['archives'][1],
self.make_local(
self.entry.creation_date).replace(hour=0))
self.assertEqual(context['template'], 'custom_template.html')
def test_get_calendar_entries_object_context(self):
self.publish_entry()
source_context = Context({'object': object()})
with self.assertNumQueries(2):
context = get_calendar_entries(source_context)
self.assertEqual(
context['previous_month'],
self.make_local(self.entry.creation_date).date().replace(day=1))
self.assertEqual(context['next_month'], None)
params = {'title': 'My second entry',
'content': 'My second content',
'tags': 'zinnia, test',
'status': PUBLISHED,
'creation_date': datetime(2008, 1, 15),
'slug': 'my-second-entry'}
second_entry = Entry.objects.create(**params)
second_entry.sites.add(self.site)
source_context = Context({'object': self.entry})
with self.assertNumQueries(2):
context = get_calendar_entries(source_context)
self.assertEqual(
context['previous_month'],
self.make_local(second_entry.creation_date).date().replace(day=1))
self.assertEqual(context['next_month'], None)
source_context = Context({'object': second_entry})
with self.assertNumQueries(2):
context = get_calendar_entries(source_context)
self.assertEqual(context['previous_month'], None)
self.assertEqual(
context['next_month'],
self.make_local(self.entry.creation_date).date().replace(day=1))
def test_discussion_feed_with_same_slugs(self):
"""
https://github.com/Fantomas42/django-blog-zinnia/issues/104
OK, Here I will reproduce the original case: getting a discussion
type feed, with a same slug.
The correction of this case, will need some changes in the
get_object method.
"""
entry = self.create_published_entry()
feed = EntryDiscussions()
self.assertEquals(feed.get_object(
'request', 2010, 1, 1, entry.slug), entry)
params = {'title': 'My test entry, part II',
'content': 'My content ',
'slug': 'my-test-entry',
'tags': 'tests',
'creation_date': datetime(2010, 2, 1),
'status': PUBLISHED}
entry_same_slug = Entry.objects.create(**params)
entry_same_slug.sites.add(self.site)
entry_same_slug.authors.add(self.author)
self.assertEquals(feed.get_object(
'request', 2010, 2, 1, entry_same_slug.slug), entry_same_slug)
def test_zinnia_entry_detail(self):
entry = self.first_entry
with self.assertNumQueries(1):
response = self.client.get(entry.get_absolute_url())
self.assertEqual(response.status_code, 200)
entry.sites.clear()
with self.assertNumQueries(1):
response = self.client.get(entry.get_absolute_url())
self.assertEqual(response.status_code, 404)
entry.sites.add(self.site)
entry.status = DRAFT
entry.save()
with self.assertNumQueries(2):
response = self.client.get(entry.get_absolute_url())
self.assertEqual(response.status_code, 404)
entry.status = PUBLISHED
entry.start_publication = datetime(2020, 1, 1, 12, 0)
entry.save()
with self.assertNumQueries(2):
response = self.client.get(entry.get_absolute_url())
self.assertEqual(response.status_code, 404)
entry.start_publication = None
entry.save()
with self.assertNumQueries(1):
response = self.client.get(entry.get_absolute_url())
self.assertEqual(response.status_code, 200)
def setUp(self):
params = {'title': 'My entry',
'content': 'My content',
'tags': 'zinnia, test',
'creation_date': datetime(2010, 1, 1),
'slug': 'my-entry'}
self.entry = Entry.objects.create(**params)
def test_feed_discussions_with_timezone_issue_277(self):
entry = self.create_published_entry()
entry.creation_date = datetime(2014, 1, 1, 23)
entry.save()
feed = EntryDiscussions()
self.assertEqual(feed.get_object(
'request', 2014, 1, 2, entry.slug), entry)
def test_get_calendar_entries(self):
source_context = Context()
with self.assertNumQueries(3):
context = get_calendar_entries(source_context)
self.assertEquals(context['previous_month'], None)
self.assertEquals(context['next_month'], None)
self.assertEquals(context['template'], 'zinnia/tags/calendar.html')
self.publish_entry()
with self.assertNumQueries(2):
context = get_calendar_entries(source_context,
template='custom_template.html')
self.assertEquals(context['previous_month'], datetime(2010, 1, 1))
self.assertEquals(context['next_month'], None)
self.assertEquals(context['template'], 'custom_template.html')
with self.assertNumQueries(2):
context = get_calendar_entries(source_context, 2009, 1)
self.assertEquals(context['previous_month'], None)
self.assertEquals(context['next_month'], datetime(2010, 1, 1))
source_context = Context({'month': datetime(2009, 1, 1)})
with self.assertNumQueries(2):
context = get_calendar_entries(source_context)
self.assertEquals(context['previous_month'], None)
self.assertEquals(context['next_month'], datetime(2010, 1, 1))
source_context = Context({'month': datetime(2010, 1, 1)})
with self.assertNumQueries(2):
context = get_calendar_entries(source_context)
self.assertEquals(context['previous_month'], None)
self.assertEquals(context['next_month'], None)
params = {'title': 'My second entry',
'content': 'My second content',
'tags': 'zinnia, test',
'status': PUBLISHED,
'creation_date': datetime(2008, 1, 1),
'slug': 'my-second-entry'}
site = Site.objects.get_current()
second_entry = Entry.objects.create(**params)
second_entry.sites.add(site)
source_context = Context()
with self.assertNumQueries(2):
context = get_calendar_entries(source_context, 2009, 1)
self.assertEquals(context['previous_month'], datetime(2008, 1, 1))
self.assertEquals(context['next_month'], datetime(2010, 1, 1))
with self.assertNumQueries(2):
context = get_calendar_entries(source_context)
self.assertEquals(context['previous_month'], datetime(2010, 1, 1))
self.assertEquals(context['next_month'], None)
def test_zinnia_entry_archive_month_no_timezone(self):
self.inhibit_templates(
'zinnia/archives/2010/month/01/entry_archive_month.html',
'zinnia/entry_archive_month.html')
response = self.check_publishing_context(
'/2010/01/', 1, 2, 'entry_list', 3)
self.assertTemplateUsed(
response, 'zinnia/archives/2010/month/01/entry_archive_month.html')
self.assertEqual(response.context['previous_month'], None)
self.assertEqual(response.context['next_month'], date(2010, 5, 1))
self.assertEqual(list(response.context['date_list']),
[datetime(2010, 1, 1)])
response = self.client.get('/2010/05/')
self.assertEqual(response.context['previous_month'], date(2010, 1, 1))
self.assertEqual(response.context['next_month'], None)
self.assertEqual(list(response.context['date_list']),
[datetime(2010, 5, 31)])
def test_previous_next_published_mixin(self):
site = Site.objects.get_current()
params = {'title': 'Entry 1', 'content': 'Entry 1',
'slug': 'entry-1', 'status': PUBLISHED,
'creation_date': datetime(2012, 1, 1, 12)}
entry_1 = Entry.objects.create(**params)
entry_1.sites.add(site)
params = {'title': 'Entry 2', 'content': 'Entry 2',
'slug': 'entry-2', 'status': PUBLISHED,
'creation_date': datetime(2012, 3, 15, 12)}
entry_2 = Entry.objects.create(**params)
entry_2.sites.add(site)
params = {'title': 'Entry 3', 'content': 'Entry 3',
'slug': 'entry-3', 'status': PUBLISHED,
'creation_date': datetime(2012, 6, 2, 12)}
entry_3 = Entry.objects.create(**params)
entry_3.sites.add(site)
class EntryPreviousNextPublished(PreviousNextPublishedMixin):
def get_queryset(self):
return Entry.published.all()
epnp = EntryPreviousNextPublished()
test_date = datetime(2009, 12, 1)
self.assertEquals(epnp.get_previous_month(test_date), None)
self.assertEquals(epnp.get_previous_day(test_date), None)
self.assertEquals(epnp.get_next_month(test_date), date(2012, 1, 1))
self.assertEquals(epnp.get_next_day(test_date), date(2012, 1, 1))
test_date = datetime(2012, 1, 1)
self.assertEquals(epnp.get_previous_month(test_date), None)
self.assertEquals(epnp.get_previous_day(test_date), None)
self.assertEquals(epnp.get_next_month(test_date), date(2012, 3, 1))
self.assertEquals(epnp.get_next_day(test_date), date(2012, 3, 15))
test_date = datetime(2012, 3, 15)
self.assertEquals(epnp.get_previous_month(test_date), date(2012, 1, 1))
self.assertEquals(epnp.get_previous_day(test_date), date(2012, 1, 1))
self.assertEquals(epnp.get_next_month(test_date), date(2012, 6, 1))
self.assertEquals(epnp.get_next_day(test_date), date(2012, 6, 2))
test_date = datetime(2012, 6, 2)
self.assertEquals(epnp.get_previous_month(test_date), date(2012, 3, 1))
self.assertEquals(epnp.get_previous_day(test_date), date(2012, 3, 15))
self.assertEquals(epnp.get_next_month(test_date), None)
self.assertEquals(epnp.get_next_day(test_date), None)
test_date = datetime(2013, 5, 1)
self.assertEquals(epnp.get_previous_month(test_date), date(2012, 6, 1))
self.assertEquals(epnp.get_previous_day(test_date), date(2012, 6, 2))
self.assertEquals(epnp.get_next_month(test_date), None)
self.assertEquals(epnp.get_next_day(test_date), None)
def test_put_on_top(self):
original_ping_directories = settings.PING_DIRECTORIES
settings.PING_DIRECTORIES = []
self.request._messages = TestMessageBackend()
self.entry.creation_date = datetime(2011, 1, 1, 12, 0)
self.admin.put_on_top(self.request, Entry.objects.all())
self.assertEquals(Entry.objects.get(pk=self.entry.pk).creation_date.date(), timezone.now().date())
self.assertEquals(len(self.request._messages.messages), 1)
settings.PING_DIRECTORIES = original_ping_directories
def test_previous_next_entry_in_one_query(self):
site = Site.objects.get_current()
self.entry.status = PUBLISHED
self.entry.save()
self.entry.sites.add(site)
if supports_savepoints:
expected_query_count = 1
else:
expected_query_count = 1
with self.assertNumQueries(expected_query_count):
self.assertFalse(self.entry.next_entry)
# Reload to check the cache
self.assertFalse(self.entry.previous_entry)
self.assertFalse(self.entry.next_entry)
params = {
"title": "My second entry",
"content": "My second content",
"slug": "my-second-entry",
"creation_date": datetime(2001, 1, 1),
"status": PUBLISHED,
}
self.second_entry = Entry.objects.create(**params)
self.second_entry.sites.add(site)
params = {
"title": "My third entry",
"content": "My third content",
"slug": "my-third-entry",
"creation_date": datetime(2050, 1, 1),
"status": PUBLISHED,
}
self.third_entry = Entry.objects.create(**params)
self.third_entry.sites.add(site)
del self.entry.previous_next # Invalidate the cached property
if supports_savepoints:
expected_query_count = 1
else:
expected_query_count = 1
with self.assertNumQueries(expected_query_count):
self.assertEqual(self.entry.previous_entry, self.second_entry)
self.assertEqual(self.entry.next_entry, self.third_entry)
# Reload to check the cache
self.assertEqual(self.entry.previous_entry, self.second_entry)
self.assertEqual(self.entry.next_entry, self.third_entry)
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_next_entry(self):
site = Site.objects.get_current()
self.assertFalse(self.entry.next_entry)
params = {'title': 'My second entry',
'content': 'My second content',
'slug': 'my-second-entry',
'creation_date': datetime(2100, 1, 1),
'status': PUBLISHED}
self.second_entry = Entry.objects.create(**params)
self.second_entry.sites.add(site)
self.assertEquals(self.entry.next_entry, self.second_entry)
params = {'title': 'My third entry',
'content': 'My third content',
'slug': 'my-third-entry',
'creation_date': datetime(2050, 1, 1),
'status': PUBLISHED}
self.third_entry = Entry.objects.create(**params)
self.third_entry.sites.add(site)
self.assertEquals(self.entry.next_entry, self.third_entry)
self.assertEquals(self.third_entry.next_entry, self.second_entry)
def test_entries_published(self):
self.assertEqual(entries_published(Entry.objects.all()).count(), 1)
self.entry_2.status = PUBLISHED
self.entry_2.save()
self.assertEqual(entries_published(Entry.objects.all()).count(), 2)
self.entry_1.sites.clear()
self.assertEqual(entries_published(Entry.objects.all()).count(), 1)
self.entry_1.sites.add(*self.sites)
self.entry_1.start_publication = datetime(2020, 1, 1)
self.entry_1.save()
self.assertEqual(entries_published(Entry.objects.all()).count(), 1)
self.entry_1.start_publication = datetime(2000, 1, 1)
self.entry_1.save()
self.assertEqual(entries_published(Entry.objects.all()).count(), 2)
self.entry_1.end_publication = datetime(2000, 1, 1)
self.entry_1.save()
self.assertEqual(entries_published(Entry.objects.all()).count(), 1)
self.entry_1.end_publication = datetime(2020, 1, 1)
self.entry_1.save()
self.assertEqual(entries_published(Entry.objects.all()).count(), 2)
def test_entry_published_manager_get_query_set(self):
self.assertEqual(Entry.published.count(), 1)
self.entry_2.status = PUBLISHED
self.entry_2.save()
self.assertEqual(Entry.published.count(), 2)
self.entry_1.sites.clear()
self.assertEqual(Entry.published.count(), 1)
self.entry_1.sites.add(*self.sites)
self.entry_1.start_publication = datetime(2020, 1, 1)
self.entry_1.save()
self.assertEqual(Entry.published.count(), 1)
self.entry_1.start_publication = datetime(2000, 1, 1)
self.entry_1.save()
self.assertEqual(Entry.published.count(), 2)
self.entry_1.end_publication = datetime(2000, 1, 1)
self.entry_1.save()
self.assertEqual(Entry.published.count(), 1)
self.entry_1.end_publication = datetime(2020, 1, 1)
self.entry_1.save()
self.assertEqual(Entry.published.count(), 2)
def test_zinnia_category_detail_paginated(self):
"""Test case reproducing issue #42 on category
detail view paginated"""
self.inhibit_templates('zinnia/entry_list.html')
for i in range(PAGINATION):
params = {
'title': 'My entry %i' % i,
'content': 'My content %i' % i,
'slug': 'my-entry-%i' % i,
'creation_date': datetime(2010, 1, 1),
'status': PUBLISHED
}
entry = Entry.objects.create(**params)
entry.sites.add(self.site)
entry.categories.add(self.category)
response = self.client.get('/categories/tests/')
self.assertEqual(len(response.context['object_list']), PAGINATION)
response = self.client.get('/categories/tests/?page=2')
self.assertEqual(len(response.context['object_list']), 2)
response = self.client.get('/categories/tests/page/2/')
self.assertEqual(len(response.context['object_list']), 2)
self.assertEqual(response.context['category'].slug, 'tests')
def test_zinnia_entry_archive_week_with_timezone(self):
self.inhibit_templates(
'zinnia/archives/2010/week/00/entry_archive_week.html',
'zinnia/entry_archive_week.html')
response = self.check_publishing_context('/2010/week/00/', 1, 2,
'entry_list', 3)
self.assertTemplateUsed(
response, 'zinnia/archives/2010/week/00/entry_archive_week.html')
# All days in a new year preceding the first Monday
# are considered to be in week 0.
self.assertEqual(response.context['week'], date(2009, 12, 28))
self.assertEqual(response.context['week_end_day'], date(2010, 1, 3))
self.assertEqual(response.context['previous_week'], None)
self.assertEqual(response.context['next_week'], date(2010, 5, 31))
self.assertEqual(response.context['date_list'][0].date(),
datetime(2010, 1, 2).date())
response = self.client.get('/2011/week/01/')
self.assertEqual(response.context['week'], date(2011, 1, 3))
self.assertEqual(response.context['week_end_day'], date(2011, 1, 9))
self.assertEqual(response.context['previous_week'], date(2010, 5, 31))
self.assertEqual(response.context['next_week'], None)
self.assertEqual(list(response.context['date_list']), [])
def test_zinnia_author_detail_paginated(self):
"""Test case reproducing issue #207 on author
detail view paginated"""
setup_test_template_loader({'zinnia/entry_list.html': ''})
for i in range(PAGINATION):
params = {
'title': 'My entry %i' % i,
'content': 'My content %i' % i,
'slug': 'my-entry-%i' % i,
'creation_date': datetime(2010, 1, 1),
'status': PUBLISHED
}
entry = Entry.objects.create(**params)
entry.sites.add(self.site)
entry.authors.add(self.author)
response = self.client.get('/authors/admin/')
self.assertEquals(len(response.context['object_list']), PAGINATION)
response = self.client.get('/authors/admin/?page=2')
self.assertEquals(len(response.context['object_list']), 2)
response = self.client.get('/authors/admin/page/2/')
self.assertEquals(len(response.context['object_list']), 2)
self.assertEquals(response.context['author'].username, 'admin')
restore_template_loaders()
def test_get_calendar_entries_object_context(self):
self.publish_entry()
source_context = Context({'object': object()})
with self.assertNumQueries(2):
context = get_calendar_entries(source_context)
self.assertEqual(
context['previous_month'],
self.make_local(self.entry.creation_date).date().replace(day=1))
self.assertEqual(context['next_month'], None)
params = {
'title': 'My second entry',
'content': 'My second content',
'tags': 'zinnia, test',
'status': PUBLISHED,
'creation_date': datetime(2008, 1, 15),
'slug': 'my-second-entry'
}
second_entry = Entry.objects.create(**params)
second_entry.sites.add(self.site)
source_context = Context({'object': self.entry})
with self.assertNumQueries(2):
context = get_calendar_entries(source_context)
self.assertEqual(
context['previous_month'],
self.make_local(second_entry.creation_date).date().replace(day=1))
self.assertEqual(context['next_month'], None)
source_context = Context({'object': second_entry})
with self.assertNumQueries(2):
context = get_calendar_entries(source_context)
self.assertEqual(context['previous_month'], None)
self.assertEqual(
context['next_month'],
self.make_local(self.entry.creation_date).date().replace(day=1))
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 test_get_absolute_url_with_timezone(self):
self.check_get_absolute_url(datetime(2013, 1, 1, 12, 0),
'/2013/01/01/my-entry/')
self.check_get_absolute_url(datetime(2013, 1, 1, 23, 0),
'/2013/01/02/my-entry/')
def test_is_visible(self):
self.assertFalse(self.entry.is_visible)
self.entry.status = PUBLISHED
self.assertTrue(self.entry.is_visible)
self.entry.start_publication = datetime(2020, 3, 15)
self.assertFalse(self.entry.is_visible)
def test_previous_next_published_mixin(self):
site = Site.objects.get_current()
params = {
'title': 'Entry 1',
'content': 'Entry 1',
'slug': 'entry-1',
'status': PUBLISHED,
'creation_date': datetime(2012, 1, 1, 12)
}
entry_1 = Entry.objects.create(**params)
entry_1.sites.add(site)
params = {
'title': 'Entry 2',
'content': 'Entry 2',
'slug': 'entry-2',
'status': PUBLISHED,
'creation_date': datetime(2012, 3, 15, 12)
}
entry_2 = Entry.objects.create(**params)
entry_2.sites.add(site)
params = {
'title': 'Entry 3',
'content': 'Entry 3',
'slug': 'entry-3',
'status': PUBLISHED,
'creation_date': datetime(2013, 6, 2, 12)
}
entry_3 = Entry.objects.create(**params)
entry_3.sites.add(site)
class EntryPreviousNextPublished(PreviousNextPublishedMixin):
def get_queryset(self):
return Entry.published.all()
test_date = datetime(2009, 12, 1)
epnp = EntryPreviousNextPublished()
self.assertEqual(epnp.get_previous_year(test_date), None)
self.assertEqual(epnp.get_previous_week(test_date), None)
self.assertEqual(epnp.get_previous_month(test_date), None)
self.assertEqual(epnp.get_previous_day(test_date), None)
self.assertEqual(epnp.get_next_year(test_date), date(2012, 1, 1))
self.assertEqual(epnp.get_next_week(test_date), date(2011, 12, 26))
self.assertEqual(epnp.get_next_month(test_date), date(2012, 1, 1))
self.assertEqual(epnp.get_next_day(test_date), date(2012, 1, 1))
test_date = datetime(2012, 1, 1)
epnp = EntryPreviousNextPublished()
self.assertEqual(epnp.get_previous_year(test_date), None)
self.assertEqual(epnp.get_previous_week(test_date), None)
self.assertEqual(epnp.get_previous_month(test_date), None)
self.assertEqual(epnp.get_previous_day(test_date), None)
self.assertEqual(epnp.get_next_year(test_date), date(2013, 1, 1))
self.assertEqual(epnp.get_next_week(test_date), date(2012, 3, 12))
self.assertEqual(epnp.get_next_month(test_date), date(2012, 3, 1))
self.assertEqual(epnp.get_next_day(test_date), date(2012, 3, 15))
test_date = datetime(2012, 3, 15)
epnp = EntryPreviousNextPublished()
self.assertEqual(epnp.get_previous_year(test_date), None)
self.assertEqual(epnp.get_previous_week(test_date), date(2011, 12, 26))
self.assertEqual(epnp.get_previous_month(test_date), date(2012, 1, 1))
self.assertEqual(epnp.get_previous_day(test_date), date(2012, 1, 1))
self.assertEqual(epnp.get_next_year(test_date), date(2013, 1, 1))
self.assertEqual(epnp.get_next_week(test_date), date(2013, 5, 27))
self.assertEqual(epnp.get_next_month(test_date), date(2013, 6, 1))
self.assertEqual(epnp.get_next_day(test_date), date(2013, 6, 2))
test_date = datetime(2013, 6, 2)
epnp = EntryPreviousNextPublished()
self.assertEqual(epnp.get_previous_year(test_date), date(2012, 1, 1))
self.assertEqual(epnp.get_previous_week(test_date), date(2012, 3, 12))
self.assertEqual(epnp.get_previous_month(test_date), date(2012, 3, 1))
self.assertEqual(epnp.get_previous_day(test_date), date(2012, 3, 15))
self.assertEqual(epnp.get_next_year(test_date), None)
self.assertEqual(epnp.get_next_week(test_date), None)
self.assertEqual(epnp.get_next_month(test_date), None)
self.assertEqual(epnp.get_next_day(test_date), None)
test_date = datetime(2014, 5, 1)
epnp = EntryPreviousNextPublished()
self.assertEqual(epnp.get_previous_year(test_date), date(2013, 1, 1))
self.assertEqual(epnp.get_previous_week(test_date), date(2013, 5, 27))
self.assertEqual(epnp.get_previous_month(test_date), date(2013, 6, 1))
self.assertEqual(epnp.get_previous_day(test_date), date(2013, 6, 2))
self.assertEqual(epnp.get_next_year(test_date), None)
self.assertEqual(epnp.get_next_week(test_date), None)
self.assertEqual(epnp.get_next_month(test_date), None)
self.assertEqual(epnp.get_next_day(test_date), None)
def test_publication_date(self):
self.assertEqual(self.entry.publication_date,
self.entry.creation_date)
self.entry.start_publication = datetime(2020, 3, 15)
self.assertEqual(self.entry.publication_date,
self.entry.start_publication)
def test_week_number(self):
self.assertEqual(week_number(datetime(2013, 1, 1)), '0')
self.assertEqual(week_number(datetime(2013, 12, 21)), '50')
