def test_if_app_installed(self):
# overwrite apps that are installed
old_ia = settings.INSTALLED_APPS
settings.INSTALLED_APPS = ['django.admin', 'mycompany.firstapp', 'foreign.app']
# test for app installed
out = Template("{% load if_app_installed %}"
"{% ifappinstalled mycompany.firstapp %}"
" {{ hello }}"
"{% endifappinstalled %}"
).render(Context({ 'hello': 'the first app is installed'}))
self.assertEqual(out.strip(), 'the first app is installed')
# test for app not installed
out = Template("{% load if_app_installed %}"
"{% ifappinstalled app.neverinstalled %}"
" {{ hello }}"
"{% endifappinstalled %}"
).render(Context({ 'hello': 'the first app is installed'}))
self.assertEqual(out.strip(), '')
# parameter missing
render = lambda t: Template(t).render(Context())
self.assertRaises(TemplateSyntaxError, render,
"{% load if_app_installed %}"
"{% ifappinstalled %}"
" string"
"{% endifappinstalled %}"
)
# restore settings.INSTALLED_APP
settings.INSTALLED_APPS = old_ia
def _content_tree(self, structure, content_map, context):
"""
Creates a tree of pages and sections within using the given ``structure`` and ``content_map``.
Body is rendered as a template with the given context.
e.g.
[
{'title': 'Page 1', 'is_empty': False, sections': [
{'attribute': 'summary', 'title': 'Summary', 'html': '...', 'is_empty': False}
]},
{'title': 'Page 2', 'is_empty': True, sections': [
{'attribute': 'overview', 'title': 'Overview', 'html': '', 'is_empty': True}
]},
]
"""
parts = []
if not structure:
return parts
for part in structure:
left, right = part.items()[0]
if isinstance(right, list):
sections = self._content_tree(right, content_map, context)
is_empty = all(x['is_empty'] for x in sections)
parts.append({'title': left, 'sections': sections, 'is_empty': is_empty})
else:
src = content_map.get(left, '')
try:
html = Template(src).render(context)
except Exception, e:
html = '<div class="template-error"><strong>Error rendering body</strong><br>%s: %s<br>%s</div>' % (e.__class__.__name__, e, traceback.format_exc())
is_empty = not bool( html.strip() )
parts.append({'attribute': left, 'title': right, 'html': html, 'src': src, 'is_empty': is_empty})
def get_email_list(self):
if self.signal.group:
return self.signal.group.slug
email_list = Template(self.signal.rules).render(Context(self.kwargs))
self.kwargs.pop('users', None)
return email_list.strip().replace('\r', '').replace('\n', '')
def data_table_attr(context, attr, verbose_name=None, obj=None, caps=False):
if obj is None:
obj = context['object']
value = obj
for attr_part in attr.split('.'):
if value is None:
break
value = getattr(value, attr_part)
if callable(value):
value = value()
if not value:
return ''
# Renders value using language preferences (as in a template).
sub_context = copy(context)
sub_context['value'] = value
value = Template('{{ value }}').render(sub_context)
if verbose_name is None:
try:
verbose_name = obj._meta.get_field(attr.split('.')[0]).verbose_name
except FieldDoesNotExist:
verbose_name = getattr(obj, attr).short_description
if caps:
value = capfirst(value.strip())
c = {
'verbose_name': verbose_name,
'value': value,
}
return render_to_string('routines/data_table_attr.html', c)
def test_simple_usage_outputs_list_of_items(self):
out = Template(
'{% load mapentity_tags %}'
'{% valuelist items %}'
).render(Context({
'items': ['blah']
}))
self.assertEqual(out.strip(), """<ul>\n <li>blah</li>\n </ul>""")
def test_empty_list_should_show_none(self):
out = Template(
'{% load mapentity_tags %}'
'{% valuelist items %}'
).render(Context({
'items': []
}))
self.assertEqual(out.strip(), '<span class="none">None</span>')
def test_user_bar_content_no_user(self):
out = Template(
"{% load semcomp %}"
"{% render_user_bar %}"
).render(Context({
'user': self.anon_user
}))
self.assertEqual(out.strip(), "")
def test_can_specify_field_to_be_used(self):
obj = DummyModel(name='blah')
out = Template(
'{% load mapentity_tags %}'
'{% valuelist items field="name" %}'
).render(Context({
'items': [obj]
}))
self.assertEqual(out.strip(), """<ul>\n <li>blah</li>\n </ul>""")
def add(source, target):
if os.path.isfile(source):
if source.endswith('->'):
content = read_file(source)
rendered_content = Template(unicode(content)).render(template_context)
links.append((rendered_content.strip(), target[:-2]),)
else:
files.append(target)
elif os.path.exists(source):
dirs.append(target)
def test_render_poll_form_no_poll(self):
"""
should display nothing
"""
topic = utils.create_topic(category=self.category, user=self.user)
out = Template("{% load spirit_tags %}" "{% render_poll_form topic=topic user=user %}").render(
Context({"topic": topic, "user": self.user})
)
self.assertEqual(out.strip(), "")
def test_edit_tag(self):
contact = Contact.objects.get(pk=1)
link = reverse("admin:core_contact_change", args=(contact.pk,))
full_link = '<a href="%s">edit (%s)</a>' % (link, contact)
template = "{% load get_edit_link %} {% edit_link contact %}"
data = {
'contact': contact,
}
response = Template(template).render(Context(data))
self.assertEqual(response.strip(), full_link)
def test_tag(self):
out = Template(
"""
{% load urlencode %}
{% urlencode param1=value1 param2="test this" %}
"""
).render(Context({'value1': 1}))
self.assertIn(
out.strip(),
['param1=1&param2=test+this', 'param2=test+this&param1=1'],
)
def test_render_polls_template_form_close(self):
"""
Should display the close button
"""
out = Template(
"{% load spirit_tags %}"
"{% post_render_comment comment=comment %}"
).render(Context({'comment': self.user_comment_with_polls, 'request': self.request, 'csrf_token': 'foo'}))
self.assertNotEqual(out.strip(), "")
close_link = reverse('spirit:comment:poll:close', kwargs={'pk': self.user_poll.pk})
self.assertTrue(close_link in out)
def test_render_poll_form(self):
"""
should display poll vote form
"""
out = Template("{% load spirit_tags %}" "{% render_poll_form topic=topic user=user %}").render(
Context({"topic": self.topic, "user": self.user})
)
self.assertNotEqual(out.strip(), "")
context = render_poll_form(self.topic, self.user)
self.assertEqual(context["next"], None)
self.assertIsInstance(context["form"], TopicPollVoteManyForm)
self.assertEqual(context["poll"], self.poll)
def test_render_polls_template_form_not_author(self):
"""
Should display poll vote form
"""
request = RequestFactory().get('/')
request.user = utils.create_user()
out = Template(
"{% load spirit_tags %}"
"{% post_render_comment comment=comment %}"
).render(Context({'comment': self.user_comment_with_polls, 'request': request, 'csrf_token': 'foo'}))
self.assertNotEqual(out.strip(), "")
form_id = 'id="p%s"' % self.user_poll.pk
self.assertTrue(form_id in out)
def test_render_polls_template_form_open(self):
"""
Should display the open button
"""
self.user_comment_with_polls.polls[0].close_at = timezone.now() # renders results.html
out = Template(
"{% load spirit_tags %}"
"{% post_render_comment comment=comment %}"
).render(Context({'comment': self.user_comment_with_polls, 'request': self.request, 'csrf_token': 'foo'}))
self.assertNotEqual(out.strip(), "")
open_link = reverse('spirit:comment:poll:open', kwargs={'pk': self.user_poll.pk})
self.assertTrue(open_link in out)
def test_render_polls_template_form_close_not_author(self):
"""
Should *not* display the close button to not poll author
"""
request = RequestFactory().get('/')
request.user = utils.create_user()
out = Template(
"{% load spirit_tags %}"
"{% post_render_comment comment=comment %}"
).render(Context({'comment': self.user_comment_with_polls, 'request': request, 'csrf_token': 'foo'}))
self.assertNotEqual(out.strip(), "")
close_link = reverse('spirit:comment:poll:close', kwargs={'pk': self.user_poll.pk})
self.assertTrue(close_link not in out)
def _format_field(options, name, data, allow_html=False, allow_empty=False):
template = options[name]
try:
result = Template(template).render(Context(data, autoescape=allow_html))
except TemplateSyntaxError as e:
raise CommandError("Invalid syntax for --{0}='{1}'\n{2}".format(name, template, e))
if not result.strip() and not allow_empty:
raise CommandError("No results for the '{0}' fields, please update --{0}. It currently uses '{1}'.".format(name, template))
if allow_html:
return result
else:
return unicode(result)
def test_render_polls_template_form(self):
"""
Should display poll vote form
"""
out = Template(
"{% load spirit_tags %}"
"{% post_render_comment comment=comment %}"
).render(Context({'comment': self.user_comment_with_polls, 'request': self.request, 'csrf_token': 'foo'}))
self.assertNotEqual(out.strip(), "")
self.assertTrue("<poll" not in out)
form_id = 'id="p%s"' % self.user_poll.pk
self.assertTrue(form_id in out)
show_link = '?show_poll=%(pk)s#p%(pk)s' % {'pk': self.user_poll.pk}
self.assertTrue(show_link in out)
def test_render_poll_form(self):
"""
should display poll vote form
"""
out = Template(
"{% load foro_tags %}"
"{% render_poll_form topic=topic user=user %}"
).render(Context({'topic': self.topic, 'user': self.user}))
self.assertNotEqual(out.strip(), "")
context = render_poll_form(self.topic, self.user)
self.assertEqual(context['next'], None)
self.assertIsInstance(context['form'], TopicPollVoteManyForm)
self.assertEqual(context['poll'], self.poll)
def test_render_polls_secret(self):
"""
Should not display the view results link when poll is secret and is not closed
"""
comment = utils.create_comment(topic=self.topic, comment_html="<poll name=bar>")
CommentPoll.objects.create(comment=comment, name='bar', mode=PollMode.SECRET)
user_comment_with_polls = comment.__class__.objects\
.filter(pk=comment.pk)\
.with_polls(self.user)\
.first()
out = Template(
"{% load spirit_tags %}"
"{% post_render_comment comment=comment %}"
).render(Context({'comment': user_comment_with_polls, 'request': self.request, 'csrf_token': 'foo'}))
self.assertNotEqual(out.strip(), "")
self.assertFalse('Show results' in out)
self.assertTrue('form' in out)
def test_render_polls_secret(self):
"""
Should not display the view results link when poll is secret and is not closed
"""
comment = utils.create_comment(topic=self.topic, comment_html="<poll name=bar>")
CommentPoll.objects.create(comment=comment, name='bar', mode=PollMode.SECRET)
user_comment_with_polls = (
comment.__class__.objects
.filter(pk=comment.pk)
.with_polls(self.user)
.first())
out = Template(
"{% load spirit_tags %}"
"{% post_render_comment comment=comment %}"
).render(Context({'comment': user_comment_with_polls, 'request': self.request, 'csrf_token': 'foo'}))
self.assertNotEqual(out.strip(), "")
self.assertFalse('Show results' in out)
self.assertTrue('form' in out)
def test_render_polls_secret_closed(self):
"""
Should display the results when poll is secret and is closed
"""
comment = utils.create_comment(topic=self.topic, comment_html="<poll name=bar>")
yesterday = timezone.now() - timezone.timedelta(days=1)
CommentPoll.objects.create(comment=comment, name='bar', mode=PollMode.SECRET, close_at=yesterday)
user_comment_with_polls = comment.__class__.objects\
.filter(pk=comment.pk)\
.with_polls(self.user)\
.first()
out = Template(
"{% load spirit_tags %}"
"{% post_render_comment comment=comment %}"
).render(Context({'comment': user_comment_with_polls, 'request': self.request, 'csrf_token': 'foo'}))
self.assertNotEqual(out.strip(), "")
self.assertFalse('show_poll=' in out)
self.assertFalse('form' in out)
self.assertTrue('comment-poll' in out)
def test_all_day_events_list(self):
# get a response object in order to use the request data for testing
request = self.client.get("/").context['request']
# test the tag with no all day events
day = Day(Event.objects.all())
c = RequestContext(request, {'day': day})
out = Template('{% load events %}{% all_day_events_list day %}').render(c)
self.assertEqual(out.strip(), "")
# test the tag with one all day event
start = datetime.datetime.combine(datetime.datetime.now(), datetime.time.min)
end = datetime.datetime.combine(datetime.datetime.now(), datetime.time.max)
cal = Calendar.objects.all().get()
Event.objects.create(start=start, end=end, all_day=True, title="Test All Day Event", calendar=cal)
day = Day(Event.objects.all())
c = RequestContext(request, {'day': day})
out = Template('{% load events %}{% all_day_events_list day %}').render(c)
self.assertTrue('Test All Day Event' in out)
def send_confirm_email(self):
self.confirm_sent = True
self.save()
if self.email == settings.FROM_EMAIL:
# ticket from ticket window
return
# email to admin
tmpl = get_template("emails/confirm.txt")
body = tmpl.render({"ticket": self})
email = EmailMessage(
_("Confirmed / %s") % self.event(), body, settings.FROM_EMAIL, [self.event().admin], reply_to=[self.email]
)
email.send(fail_silently=False)
# email to user
e = self.event().get_email()
extra = json.loads(self.extra_data)
if e:
subject = Template(e.subject).render(Context({"ticket": self, "extra": extra}))
body = Template(e.body).render(Context({"ticket": self, "extra": extra}))
else:
tmpl = get_template("emails/subject-confirm-user.txt")
subject = tmpl.render({"ticket": self, "extra": extra})
tmpl = get_template("emails/confirm-user.txt")
body = tmpl.render({"ticket": self, "extra": extra})
body = body.replace("TICKETID", self.order)
email = EmailMessage(subject.strip(), body, settings.FROM_EMAIL, [self.email])
if e:
# adding attachments
for att in e.attachs.all():
email.attach_file(att.attach.path)
filename = "ticket_%s.pdf" % self.order
email.attach(filename, self.gen_pdf(), "application/pdf")
email.send(fail_silently=False)
def test_render_polls_secret_closed(self):
"""
Should display the results when poll is secret and is closed
"""
comment = utils.create_comment(topic=self.topic, comment_html="<poll name=bar>")
yesterday = timezone.now() - timezone.timedelta(days=1)
CommentPoll.objects.create(comment=comment, name='bar', mode=PollMode.SECRET, close_at=yesterday)
user_comment_with_polls = (
comment.__class__.objects
.filter(pk=comment.pk)
.with_polls(self.user)
.first())
out = Template(
"{% load spirit_tags %}"
"{% post_render_comment comment=comment %}"
).render(Context({'comment': user_comment_with_polls, 'request': self.request, 'csrf_token': 'foo'}))
self.assertNotEqual(out.strip(), "")
self.assertFalse('show_poll=' in out)
self.assertFalse('form' in out)
self.assertTrue('comment-poll' in out)
def test_blog_months(self):
def make_blog_post(*datetime_args):
blog_post = BlogPost.objects.create(
user=self._user, status=CONTENT_STATUS_PUBLISHED,
publish_date=datetime.datetime(*datetime_args))
blog_post.save()
make_blog_post(2016, 4, 15)
make_blog_post(2017, 4, 15)
make_blog_post(2017, 4, 20)
make_blog_post(2014, 5, 15)
html = Template("""\n
{% load blog_tags %}
{% blog_months as months %}
{% for month in months %}
{{ month.date.year }}-{{ month.date.month}}: {{month.post_count}}
{% endfor %}""").render(Context({}))
months = re.sub('\n\s*', ', ', html.strip())
self.assertEqual(months, '2017-4: 2, 2016-4: 1, 2014-5: 1')
def test_blog_months(self):
def make_blog_post(*datetime_args):
publish_date = datetime.datetime(*datetime_args, tzinfo=pytz.utc)
blog_post = BlogPost.objects.create(
user=self._user, status=CONTENT_STATUS_PUBLISHED,
publish_date=publish_date)
blog_post.save()
make_blog_post(2016, 4, 15)
make_blog_post(2017, 4, 15)
make_blog_post(2017, 4, 20)
make_blog_post(2014, 5, 15)
html = Template("""\n
{% load blog_tags %}
{% blog_months as months %}
{% for month in months %}
{{ month.date.year }}-{{ month.date.month}}: {{month.post_count}}
{% endfor %}""").render(Context({}))
months = re.sub(r'\n\s*', ', ', html.strip())
self.assertEqual(months, '2017-4: 2, 2016-4: 1, 2014-5: 1')
def data_table_attr(
context,
attr,
verbose_name=None,
title=None,
obj=None,
caps=False,
):
if obj is None:
obj = context['object']
value = obj
for attr_part in attr.split('.'):
if value is None:
break
value = getattr(value, attr_part)
if callable(value):
value = value()
if not value:
return {}
# Renders value using language preferences (as in a template).
sub_context = copy(context)
sub_context['value'] = value
value = Template('{{ value }}').render(sub_context)
if verbose_name is None:
try:
verbose_name = obj._meta.get_field(attr.split('.')[0]).verbose_name
except FieldDoesNotExist:
verbose_name = getattr(obj, attr).short_description
if caps:
value = capfirst(value.strip())
return {
'verbose_name': verbose_name,
'title': title,
'value': value,
}
def test_render(self):
context = Context({})
result = Template("""
{% load mixins %}
{% mixin foo %}
<div><div>{{ name }}</div><div>{{ description }}</div></div>
{% endmixin %}
{% mix foo with name="hello" description="world" %}
----
{% mix foo with name="good" description="bye" %}
""").render(context)
expected = """
<div><div>hello</div><div>world</div></div>
----
<div><div>good</div><div>bye</div></div>
"""
self.assertEqual(expected.strip(), result.strip())
def test_template_tag(self):
with self.settings(REMINDERS=self.usual_settings):
self.factory = RequestFactory()
request = self.factory.get('/')
# Anonymous user will get no reminders
setattr(request, 'user', AnonymousUser())
t = Template(self.usual_template).render(Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Unauthenticated bob will get no reminders
bob = User.objects.get(username='******')
bob.is_authenticated = mock.MagicMock()
bob.is_authenticated.return_value = False
setattr(request, 'user', bob)
t = Template(self.usual_template).render(Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Authenticated Bob will get just the blanket message because it's prioritized first
bob.is_authenticated.return_value = True
setattr(request, 'user', bob)
t = Template(self.usual_template).render(Context({'request': request}))
self.assertEqual(t.strip(),
"Message: Remember to take out the trash URL: /reminders/dismiss/blanket/")
# Bob dismisses that one
Dismissal.objects.create(label="blanket", user=bob)
# Now Bob gets no messages, even though his name is Bob, because he just recently dismissed a message
t = Template(self.usual_template).render(Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Authenticated Wonko will just get the blanket message
wonko = User.objects.get(username='******')
wonko.is_authenticated = mock.MagicMock()
wonko.is_authenticated.return_value = True
setattr(request, 'user', wonko)
t = Template(self.usual_template).render(Context({'request': request}))
self.assertEqual(t.strip(), "Message: Remember to take out the trash URL: /reminders/dismiss/blanket/")
# Both wonko dismisses the trash/blanket one too
Dismissal.objects.create(label="blanket", user=wonko)
# Authenticated Wonko will get no messages
t = Template(self.usual_template).render(Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Authenticated Bob will get no messages
setattr(request, 'user', bob)
t = Template(self.usual_template).render(Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Now it's been a couple days since Bob dismissed that blanket one
bobs_dismissal = Dismissal.objects.get(label="blanket", user=bob)
bobs_dismissal.dismissed_at = timezone.now() - timedelta(days=2)
bobs_dismissal.save()
# Now Bob will get the show-to-bob message
t = Template(self.usual_template).render(Context({'request': request}))
self.assertEqual(t.strip(), "Message: Remember to put on pants URL: /reminders/dismiss/a_show_to_bob/")
def get_email_list(self):
if self.signal.group:
return MailGroup.get_emails(self.signal.group.slug)
email_list = Template(self.signal.rules).render(Context(self.kwargs))
return email_list.strip().replace('\r', '').replace('\n', '')
def test_can_specify_field_to_be_used(self):
obj = DummyModel(name='blah')
out = Template('{% load mapentity_tags %}'
'{% valuelist items field="name" %}').render(
Context({'items': [obj]}))
self.assertEqual(out.strip(), """<ul>\n <li>blah</li>\n </ul>""")
def render(self, template, context_dict, request=None):
context = Context(context_dict.copy())
if request is not None:
context['request'] = request
html = Template(template).render(context)
return html.strip(), context
def testRenderCommentForm(self, tag=None):
t = "{% load comments %}" + (tag or "{% render_comment_form for testapp.article a.id %}")
out = Template(t).render(RequestContext({'a': Article.objects.get(pk=1)}))
self.assertTrue(out.strip().startswith("<form action="))
self.assertTrue(out.strip().endswith("</form>"))
def test_empty_list_should_show_none(self):
translation.deactivate()
out = Template('{% load mapentity_tags %}'
'{% valuelist items %}').render(Context({'items': []}))
self.assertEqual(out.strip(), '<span class="none">None</span>')
def test_template_tag(self):
with self.settings(REMINDERS=self.usual_settings):
self.factory = RequestFactory()
request = self.factory.get('/')
# Anonymous user will get no reminders
setattr(request, 'user', AnonymousUser())
t = Template(self.usual_template).render(
Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Unauthenticated bob will get no reminders
bob = User.objects.get(username='******')
bob.is_authenticated = mock.MagicMock()
bob.is_authenticated.return_value = False
setattr(request, 'user', bob)
t = Template(self.usual_template).render(
Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Authenticated Bob will get just the blanket message because it's prioritized first
bob.is_authenticated.return_value = True
setattr(request, 'user', bob)
t = Template(self.usual_template).render(
Context({'request': request}))
self.assertEqual(
t.strip(),
"Message: Remember to take out the trash URL: /reminders/dismiss/blanket/"
)
# Bob dismisses that one
Dismissal.objects.create(label="blanket", user=bob)
# Now Bob gets no messages, even though his name is Bob, because he just recently dismissed a message
t = Template(self.usual_template).render(
Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Authenticated Wonko will just get the blanket message
wonko = User.objects.get(username='******')
wonko.is_authenticated = mock.MagicMock()
wonko.is_authenticated.return_value = True
setattr(request, 'user', wonko)
t = Template(self.usual_template).render(
Context({'request': request}))
self.assertEqual(
t.strip(),
"Message: Remember to take out the trash URL: /reminders/dismiss/blanket/"
)
# Both wonko dismisses the trash/blanket one too
Dismissal.objects.create(label="blanket", user=wonko)
# Authenticated Wonko will get no messages
t = Template(self.usual_template).render(
Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Authenticated Bob will get no messages
setattr(request, 'user', bob)
t = Template(self.usual_template).render(
Context({'request': request}))
self.assertEqual(t.strip(), "No reminders")
# Now it's been a couple days since Bob dismissed that blanket one
bobs_dismissal = Dismissal.objects.get(label="blanket", user=bob)
bobs_dismissal.dismissed_at = timezone.now() - timedelta(days=2)
bobs_dismissal.save()
# Now Bob will get the show-to-bob message
t = Template(self.usual_template).render(
Context({'request': request}))
self.assertEqual(
t.strip(),
"Message: Remember to put on pants URL: /reminders/dismiss/a_show_to_bob/"
)
def get_email_list(self):
if self.signal.group:
return self.signal.group.slug
email_list = Template(self.signal.rules).render(Context(self.kwargs))
self.kwargs.pop('users', None)
return email_list.strip().replace('\r', '').replace('\n', '')
