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/" )