def test_render_incorrect_template(self): """ Handle weird django behavior. Django caches an invalid_var_format_string at the top level of the module. So if TEMPLATE_STRING_IF_INVALID is '', it will never actually call LogInvalidVariableTemplate.__mod__ if it failed to render a template before (in the same process) while *not* in the context of a log decorator. """ with patch('django.template.base.invalid_var_format_string', None), \ patch.object(FilterExpression, 'resolve', strict_resolve): logger = Mock() template = Template('{{ a }}') template.render(Context()) from django.template import base self.assertFalse(base.invalid_var_format_string) @log_template_errors(logger) def render(): return template.render(Context()) render() self.assertTrue(logger.log.called)
def test_link_nofollow(self): # Regular page = Page(name='Explore', region=self.region) rf = RequestFactory() request = rf.get('/') content = ('<p><a href="http://example.org/">hi</a></p>') template = Template(""" {% load pages_tags %} {% render_plugins content %} """) rendered = template.render(Context({'region': self.region, 'request': request, 'content': content, 'page': page})) self.failUnless('http://example.org/' in rendered) self.assertTrue('nofollow' not in rendered) # Nofollow page = Page(name='Explore', region=self.region) rf = RequestFactory() request = rf.get('/') content = ('<p><a href="http://example.org/">hi</a></p>') template = Template(""" {% load pages_tags %} {% render_plugins_nofollow content %} """) rendered = template.render(Context({'region': self.region, 'request': request, 'content': content, 'page': page})) self.failUnless('http://example.org/' in rendered) self.assertTrue('nofollow' in rendered)
def test_raises_if_the_required_arguments_are_not_passed(self): # Setup request = self.request_factory.get('/') request.user = self.u1 ForumPermissionHandlerMiddleware().process_request(request) context = Context({'request': request}) templates = [ '{% get_permission \'can_download_files\' request.user as user_can_download_files %}' '{% if user_can_download_files %}CAN_DOWNLOAD{% else %}CANNOT_DOWNLOAD{% endif %}', '{% get_permission \'can_edit_post\' request.user as user_can_edit_post %}' '{% if user_can_edit_post %}CAN_EDIT{% else %}CANNOT_EDIT{% endif %}', '{% get_permission \'can_edit_post\' request.user as user_can_edit_post %}' '{% if user_can_edit_post %}CAN_EDIT{% else %}CANNOT_EDIT{% endif %}', '{% get_permission \'can_add_post\' request.user as user_can_add_post %}' '{% if user_can_add_post %}CAN_ADD_POST{% else %}CANNOT_ADD_POST{% endif %}', '{% get_permission \'can_vote_in_poll\' request.user as user_can_vote_in_poll %}' '{% if user_can_vote_in_poll %}CAN_VOTE{% else %}CANNOT_VOTE{% endif %}', ] # Run & check for raw_template in templates: t = Template(self.loadstatement + raw_template) with pytest.raises(TypeError): t.render(context)
def test_cached_show_placeholder_preview(self): from django.core.cache import cache cache.clear() page = create_page('Test', 'col_two.html', 'en', published=True) placeholder = page.placeholders.all()[0] add_plugin(placeholder, TextPlugin, 'en', body='<b>Test</b>') request = RequestFactory().get('/') user = User(username="******", password="******", is_superuser=True, is_staff=True, is_active=True) user.save() request.current_page = page.publisher_public request.user = user template = Template( "{% load cms_tags %}{% show_placeholder slot page 'en' 1 %}") context = RequestContext(request, {'page': page, 'slot': placeholder.slot}) with self.assertNumQueries(5): output = template.render(context) self.assertIn('<b>Test</b>', output) add_plugin(placeholder, TextPlugin, 'en', body='<b>Test2</b>') request = RequestFactory().get('/?preview') request.current_page = page request.user = user context = RequestContext(request, {'page': page, 'slot': placeholder.slot}) with self.assertNumQueries(5): output = template.render(context) self.assertIn('<b>Test2</b>', output)
def test_lookup_in_staticfiles_dirs(self): template = Template(""" {% load less %} {% less "another_test.less" %} """) compiled_filename_re = re.compile(r"LESS_CACHE/another_test-[a-f0-9]{12}.css") compiled_filename = template.render(self._get_request_context()).strip() self.assertTrue(bool(compiled_filename_re.match(compiled_filename))) compiled_path = os.path.join(self.django_settings.STATIC_ROOT, compiled_filename) compiled_content = open(compiled_path).read().strip() compiled = """#header-from-staticfiles-dir h1 { color: red; }""" self.assertEquals(compiled_content, compiled) template = Template(""" {% load less %} {% less "prefix/another_test.less" %} """) compiled_filename_re = re.compile(r"LESS_CACHE/prefix/another_test-[a-f0-9]{12}.css") compiled_filename = template.render(self._get_request_context()).strip() self.assertTrue(bool(compiled_filename_re.match(compiled_filename))) compiled_path = os.path.join(self.django_settings.STATIC_ROOT, compiled_filename) compiled_content = open(compiled_path).read().strip() compiled = """#header-from-staticfiles-dir-with-prefix h1 { color: red; }""" self.assertEquals(compiled_content, compiled)
def test_render_model_add_block(self): from django.core.cache import cache from cms.test_utils.project.sampleapp.models import Category cache.clear() page = create_page('Test', 'col_two.html', 'en', published=True) template = Template( "{% load cms_tags %}{% render_model_add_block category %}wrapped{% endrender_model_add_block %}") user = self._create_user("admin", True, True) request = RequestFactory().get('/') request.user = user request.current_page = page request.session = {} request.toolbar = CMSToolbar(request) request.toolbar.edit_mode = True request.toolbar.is_staff = True context = RequestContext(request, {'category': Category()}) with self.assertNumQueries(0): output = template.render(context) expected = 'cms_plugin cms_plugin-sampleapp-category-add-0 ' 'cms_render_model_add' self.assertIn(expected, output) # Now test that it does NOT render when not in edit mode request = RequestFactory().get('/') request.user = user request.current_page = page request.session = {} request.toolbar = CMSToolbar(request) context = RequestContext(request, {'category': Category()}) with self.assertNumQueries(0): output = template.render(context) expected = 'wrapped' self.assertEqual(expected, output)
def test_cached_show_placeholder_sekizai(self): from django.core.cache import cache cache.clear() from cms.test_utils import project template_dir = os.path.join(os.path.dirname(project.__file__), 'templates', 'alt_plugin_templates', 'show_placeholder') page = create_page('Test', 'col_two.html', 'en') placeholder = page.placeholders.all()[0] add_plugin(placeholder, TextPlugin, 'en', body='HIDDEN') request = RequestFactory().get('/') request.user = self.get_staff_user_with_no_permissions() request.current_page = page if DJANGO_1_7: override = {'TEMPLATE_DIRS': [template_dir], 'CMS_TEMPLATES': []} else: override = {'TEMPLATES': deepcopy(settings.TEMPLATES)} override['TEMPLATES'][0]['DIRS'] = [template_dir] with self.settings(**override): template = Template( "{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'en' 1 %}{% render_block 'js' %}") context = RequestContext(request, {'page': page, 'slot': placeholder.slot}) output = template.render(context) self.assertIn('JAVASCRIPT', output) context = RequestContext(request, {'page': page, 'slot': placeholder.slot}) output = template.render(context) self.assertIn('JAVASCRIPT', output)
def test_cached_show_placeholder_sekizai(self): from django.core.cache import cache cache.clear() from cms.test_utils import project User = get_user_model() template_dir = os.path.join(os.path.dirname(project.__file__), 'templates', 'alt_plugin_templates', 'show_placeholder') page = create_page('Test', 'col_two.html', 'en') placeholder = page.placeholders.all()[0] add_plugin(placeholder, TextPlugin, 'en', body='HIDDEN') request = RequestFactory().get('/') request.user = User() request.current_page = page with SettingsOverride(TEMPLATE_DIRS=[template_dir]): template = Template( "{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'en' 1 %}{% render_block 'js' %}") context = RequestContext(request, {'page': page, 'slot': placeholder.slot}) output = template.render(context) self.assertIn('JAVASCRIPT', output) context = RequestContext(request, {'page': page, 'slot': placeholder.slot}) output = template.render(context) self.assertIn('JAVASCRIPT', output)
def test_compiled_file_already_exists_file_is_not_written_again(self): template = Template(""" {% load coldbrew %} {% coffeescript "scripts/test-already-exists.coffee" %} """) # Render it once. compiled_filename = template.render(RequestContext({})).strip() first_access = os.path.getatime("%s/%s" % (settings.STATIC_ROOT, compiled_filename)) # ...and delete it. os.remove("%s/%s" % (settings.STATIC_ROOT, compiled_filename)) # Now render it agian. compiled_filename_again = template.render(RequestContext({})).strip() second_access = os.path.getatime("%s/%s" % (settings.STATIC_ROOT, compiled_filename_again)) # The file will have been accessed again. self.assertGreater(second_access, first_access) # Render it a third time - this time the file will already exist. compiled_filename_yet_again = template.render(RequestContext({})).strip() third_access = os.path.getatime("%s/%s" % (settings.STATIC_ROOT, compiled_filename_yet_again)) # Since the file already existed, we won't have written again self.assertEqual(third_access, second_access) # ...and finally delete the file now that the test is over. os.remove("%s/%s" % (settings.STATIC_ROOT, compiled_filename_yet_again))
def test_template_creation(self): self.assertObjectDoesNotExist(Stack.objects.all(), code='foobar') self.assertObjectDoesNotExist(Placeholder.objects.all(), slot='foobar') t = Template('{% load stack_tags %}{% stack "foobar" %}') t.render(self.get_context('/')) self.assertObjectExist(Stack.objects.all(), code='foobar', creation_method=Stack.CREATION_BY_TEMPLATE) self.assertObjectExist(Placeholder.objects.all(), slot='foobar')
def test_cached(): """ Test that the template still works when the cached loader is being used. """ c = Context() t = Template('{% extends "admin:admin/base.html" %}') t.render(c)
def test_render(): """ Test-drive the apptemplate code base by rendering a template. """ c = Context() t = Template('{% extends "admin:admin/base.html" %}') t.render(c)
def render_html(self): """Return rendered HTML if the email is html or md""" if self.get_email_type() not in ['html', 'md']: return None # render content and fix urls/emails template = self.get_template() template = Template(template) template = template.render(Context(self.payload)) if not self.urls_resolved: template = self.fix_urls(template) if self.get_email_type() == 'md': template = markdown(template) self.payload['site'] = Site.objects.get_current() if not self.use_base_template: return template base_template = ( "{{% extends '{base_template}' %}}{{% block {block_name} %}}\n" "{template}\n" "{{% endblock %}}" ).format( base_template=settings.EMAILMELD_BASE_TEMPLATE, block_name="content", template=template, ) base_template = Template(base_template) base_template = base_template.render(Context(self.payload)) return base_template
def render_and_email(to_list, subject, text_template = None, html_template = None, context_dic = None): ''' This method gets a list of recipients, a subject text, text_template (for showing in web readers and mobile apps), an HTML_template for displaying in browsers and a context dictionary, renders templates with context and sends an email. Note that if text_template is a filename, method loads it, otherwise uses it as string (And same for html_template). ''' from_email = '*****@*****.**' context = Context(context_dic) if text_template: try: plaintext = get_template(text_template) except: plaintext = Template(text_template) text_content = plaintext.render(context) else: text_content = '(EMPTY)' msg = EmailMultiAlternatives(subject, text_content, from_email, to_list) if html_template: try: htmly = get_template(html_template) except: htmly = Template(html_template) html_content = htmly.render(context) msg.attach_alternative(html_content, "text/html") msg.send()
def test_template_creation(self): self.assertObjectDoesNotExist(StaticPlaceholder.objects.all(), code='foobar') self.assertObjectDoesNotExist(Placeholder.objects.all(), slot='foobar') t = Template('{% load cms_tags %}{% static_placeholder "foobar" %}') t.render(self.get_context('/')) self.assertObjectExist(StaticPlaceholder.objects.all(), code='foobar', creation_method=StaticPlaceholder.CREATION_BY_TEMPLATE) self.assertEqual(Placeholder.objects.filter(slot='foobar').count(), 2)
def test_ifdef_body_still_fails_for_undefined_variables(self): ifdef_template = Template( "{% load pedant_tags %}\n{% ifdef a %}{{ b }}{% endifdef %}") self.assertEqual( ifdef_template.render(Context({'a': 'a', 'b': 'b'})).strip(), 'b') with self.assertRaises(PedanticTemplateRenderingError): ifdef_template.render(Context({'a': 'a'}))
def test_empty(self): self.assertObjectDoesNotExist(StaticPlaceholder.objects.all(), code='foobar') self.assertObjectDoesNotExist(Placeholder.objects.all(), slot='foobar') t = Template('{% load cms_tags %}{% static_placeholder "foobar" or %}No Content{% endstatic_placeholder %}') rendered = t.render(self.get_context('/')) self.assertIn("No Content", rendered) for p in Placeholder.objects.all(): add_plugin(p, 'TextPlugin', 'en', body='test') rendered = t.render(self.get_context('/')) self.assertNotIn("No Content", rendered)
def test_local(self): self.assertObjectDoesNotExist(StaticPlaceholder.objects.all(), code='foobar') self.assertObjectDoesNotExist(Placeholder.objects.all(), slot='foobar') t = Template('{% load cms_tags %}{% static_placeholder "foobar" site or %}No Content{% endstatic_placeholder %}') rendered = t.render(self.get_context('/')) self.assertIn("No Content", rendered) for p in Placeholder.objects.all(): add_plugin(p, 'TextPlugin', 'en', body='test') rendered = t.render(self.get_context('/')) self.assertNotIn("No Content", rendered) self.assertEqual(StaticPlaceholder.objects.filter(site_id__isnull=False, code='foobar').count(), 1)
def test_render_incorrect_template(self): with patch('django.template.base.invalid_var_format_string', None), \ patch.object(FilterExpression, 'resolve', strict_resolve): template = Template('{{ a }}') template.render(Context()) from django.template import base self.assertFalse(base.invalid_var_format_string) with self.assertRaises(PedanticTemplateRenderingError): PedanticTemplate('{{ a }}').render(Context()) PedanticTemplate('{{ a }}').render(Context({'a': 'a'}))
def test_error_quiet(self): # Start by clearing the error message list. logger.handlers[0].messages['error'] = [] template = Template(""" {% load coldbrew %} {% coffeescript "scripts/test-error.coffee" %} """) template.render(RequestContext({})).strip() # Now we got an error from the rendering. errors = logger.handlers[0].messages['error'] self.assertTrue("Unexpected 'INDENT'" in errors[0])
def render_to_response(self, context, **response_kwargs): if self.template_string: context = RequestContext(request=self.request, dict_=context) if DJANGO_1_7: template = Template(self.template_string) return HttpResponse(template.render(context)) else: from django.template.engine import Engine engine = Engine.get_default() template = engine.from_string(self.template_string) return HttpResponse(template.render(context)) else: return super(ClassDetail, self).render_to_response(context, **response_kwargs)
def test_untranslated_language_url(self): """ Tests page_language_url templatetag behavior when used on a page without the requested translation, both when CMS_HIDE_UNTRANSLATED is True and False. When True it should return the root page URL if the current page is untranslated (PR #1125) """ page_1 = create_page('Page 1', 'nav_playground.html', 'en', published=True, in_navigation=True, reverse_id='page1') create_title("de", "Seite 1", page_1, slug="seite-1") page_1.publish('en') page_1.publish('de') page_2 = create_page('Page 2', 'nav_playground.html', 'en', page_1, published=True, in_navigation=True, reverse_id='page2') create_title("de", "Seite 2", page_2, slug="seite-2") page_2.publish('en') page_2.publish('de') page_3 = create_page('Page 3', 'nav_playground.html', 'en', page_2, published=True, in_navigation=True, reverse_id='page3') tpl = Template("{% load menu_tags %}{% page_language_url 'de' %}") lang_settings = copy.deepcopy(get_cms_setting('LANGUAGES')) lang_settings[1][1]['hide_untranslated'] = False with SettingsOverride(CMS_LANGUAGES=lang_settings): context = self.get_context(page_2.get_absolute_url()) context['request'].current_page = page_2 res = tpl.render(context) self.assertEqual(res, "/de/seite-2/") # Default configuration has CMS_HIDE_UNTRANSLATED=False context = self.get_context(page_2.get_absolute_url()) context['request'].current_page = page_2.publisher_public res = tpl.render(context) self.assertEqual(res, "/de/seite-2/") context = self.get_context(page_3.get_absolute_url()) context['request'].current_page = page_3.publisher_public res = tpl.render(context) self.assertEqual(res, "/de/page-3/") lang_settings[1][1]['hide_untranslated'] = True with SettingsOverride(CMS_LANGUAGES=lang_settings): context = self.get_context(page_2.get_absolute_url()) context['request'].current_page = page_2.publisher_public res = tpl.render(context) self.assertEqual(res, "/de/seite-2/") context = self.get_context(page_3.get_absolute_url()) context['request'].current_page = page_3.publisher_public res = tpl.render(context) self.assertEqual(res, "/de/")
def test_render_placeholder_as_var(self): page = create_page('Test', 'col_two.html', 'en', published=True) template = Template( "{% load cms_tags %}{% placeholder test or %}< --- empty --->{% endplaceholder %}") request = RequestFactory().get('/asdadsaasd/') user = self.get_superuser() request.user = user request.current_page = page request.session = {} request.toolbar = CMSToolbar(request) request.toolbar.edit_mode = True request.toolbar.is_staff = True context = RequestContext(request) with self.assertNumQueries(4): template.render(context)
def test_link_to_anchor_relative(self): a = Page(name='Front Page', region=self.region) a.content = (u'<a href="A%20Page#anchor">dummy</a>') a.save() context = Context({'page': a, 'region': self.region}) template = Template(html_to_template_text(a.content, context)) html = template.render(context) self.assertEqual(html, u'<a href="/test-region/A_Page#anchor" class="missing_link">dummy</a>') a.content = (u'<a href="#justanchor">dummy</a>') context = Context({'page': a, 'region': self.region}) template = Template(html_to_template_text(a.content, context)) html = template.render(context) self.assertEqual(html, u'<a href="#justanchor">dummy</a>')
def test_custom_bound_field(): from django.forms.boundfield import BoundField extra = 'xyxyxyxyxyx' class CustomBoundField(BoundField): @property def auto_id(self): return extra class MyCharField(forms.CharField): def get_bound_field(self, form, field_name): return CustomBoundField(form, self, field_name) class MyForm(forms.Form): f = MyCharField() def __init__(self, *args, **kwargs): super(MyForm, self).__init__(*args, **kwargs) self.helper = FormHelper() self.helper.layout = Layout('f') template = Template('{% load crispy_forms_tags %}\n{% crispy form "bootstrap3" %}') rendered = template.render(Context({'form': MyForm(data={'f': 'something'})})) assert extra in rendered
def render(self, context): filepath = self.filepath if not self.legacy_filepath: filepath = filepath.resolve(context) if not include_is_allowed(filepath): if settings.DEBUG: return "[Didn't have permission to include file]" else: return '' # Fail silently for invalid includes. try: fp = open(filepath, 'r') output = fp.read() fp.close() except IOError: output = '' if self.parsed: try: t = Template(output, name=filepath) return t.render(context) except TemplateSyntaxError, e: if settings.DEBUG: return "[Included template had syntax error: %s]" % e else: return '' # Fail silently for invalid included templates.
def conflict(request, target=None, template_name='409.html'): """ 409 error handler. Templates: :template:`409.html` Context: target The model to save saved The object stored in the db that produce the conflict or None if not found (ie. deleted) request_path The path of the requested URL (e.g., '/app/pages/bad_page/') """ try: template = loader.get_template(template_name) except TemplateDoesNotExist: template = Template( '<h1>Conflict</h1>' '<p>The request was unsuccessful due to a conflict. ' 'The object changed during the transaction.</p>') try: saved = target.__class__.objects.get(pk=target.pk) except target.__class__.DoesNotExists: saved = None ctx = RequestContext(request, {'target': target, 'saved': saved, 'request_path': request.path}) return ConflictResponse(template.render(ctx))
def conflict(request, target=None, template_name='409.html'): """409 error handler. :param request: Request :param template_name: `409.html` :param target: The model to save """ try: template = loader.get_template(template_name) except TemplateDoesNotExist: template = Template( '<h1>Conflict</h1>' '<p>The request was unsuccessful due to a conflict. ' 'The object changed during the transaction.</p>') try: saved = target.__class__._default_manager.get(pk=target.pk) except target.__class__.DoesNotExist: saved = None ctx = {'target': target, 'saved': saved, 'request_path': request.path} return ConflictResponse(template.render(ctx))
def test_can_render_a_list_of_forums_according_to_their_minimum_tree_level(self): # Setup forums = Forum.objects.all() request = self.request_factory.get('/') middleware = SessionMiddleware() middleware.process_request(request) request.session.save() request.user = self.user ForumPermissionMiddleware().process_request(request) t = Template(self.loadstatement + '{% forum_list forums %}') c = Context({'forums': forums, 'request': request}) expected_out = render_to_string( 'machina/forum/forum_list.html', { 'forums': forums, 'user': self.user, 'root_level': 0, 'root_level_middle': 1, 'root_level_sub': 2, } ) # Run rendered = t.render(c) # Check assert rendered != '' assert rendered == expected_out
def test_embed_whitelist_reject(self): html = ('<span class="plugin embed"><iframe src="http://evil.com"' '></iframe></span>') template = Template(html_to_template_text(html)) rendered = template.render(Context()) self.failUnless(('The embedded URL is not on the list of approved ' 'providers') in rendered)
def test_imports(self): template = Template(""" {% load less %} {% less "styles/import.less" %} """) compiled_filename = template.render(self._get_request_context()).strip() compiled_path = os.path.join(self.django_settings.STATIC_ROOT, compiled_filename) compiled_content = open(compiled_path).read().strip() compiled = """h1 { color: red; }""" self.assertEquals(compiled_content, compiled)
def get_rendered(topic, user): request = self.get_request() request.user = user ForumPermissionMiddleware().process_request(request) t = Template( self.loadstatement + '{% get_permission \'can_add_post\' topic request.user as user_can_add_post %}' '{% if user_can_add_post %}CAN_ADD_POST{% else %}CANNOT_ADD_POST{% endif %}' ) c = Context({'topic': topic, 'request': request}) rendered = t.render(c) return rendered
def get_rendered(post, user): request = self.get_request() request.user = user ForumPermissionMiddleware().process_request(request) t = Template( self.loadstatement + '{% get_permission \'can_download_files\' post.topic.forum request.user as user_can_download_files %}' # noqa '{% if user_can_download_files %}CAN_DOWNLOAD{% else %}CANNOT_DOWNLOAD{% endif %}' ) c = Context({'post': post, 'request': request}) rendered = t.render(c) return rendered
def test_embed_with_query_multiple(self): # Test multiple KEY=VALUE arguments template = Template(""" {% load embed_video_tags %} {% video 'http://www.youtube.com/watch?v=jsrRJyHBvzw' rel=0 loop=1 end=5 %} """) expected = { 'rel': ['0'], 'loop': ['1'], 'end': ['5'], 'wmode': ['opaque'] } self._validate_GET_query(template.render(self._grc()), expected)
def get_rendered(forum, user): request = self.get_request() request.user = user ForumPermissionMiddleware().process_request(request) t = Template( self.loadstatement + '{% get_permission \'can_add_topic\' forum request.user as user_can_add_topic %}' '{% if user_can_add_topic %}CAN_START_TOPICS{% else %}CANNOT_START_TOPICS{% endif %}' ) # noqa c = Context({'forum': forum, 'request': request}) rendered = t.render(c) return rendered
def get_rendered(poll, user): request = self.get_request() request.user = user ForumPermissionMiddleware().process_request(request) t = Template( self.loadstatement + '{% get_permission \'can_vote_in_poll\' poll request.user as user_can_vote_in_poll %}' # noqa '{% if user_can_vote_in_poll %}CAN_VOTE{% else %}CANNOT_VOTE{% endif %}' ) c = Context({'poll': poll, 'request': request}) rendered = t.render(c) return rendered
def get_rendered(user): request = self.get_request() request.user = user ForumPermissionMiddleware().process_request(request) t = Template( self.loadstatement + '{% get_permission \'can_access_moderation_queue\' request.user as user_can_access_moderation_queue %}' # noqa '{% if user_can_access_moderation_queue %}CAN_ACCESS{% else %}CANNOT_ACCESS{% endif %}' ) # noqa c = Context({'request': request}) rendered = t.render(c) return rendered
def test_include_plugin(self): a = Page(name='Front Page') a.content = '<a class="plugin includepage" href="Explore">dummy</a>' a.save() b = Page(name='Explore') b.content = '<p>Some text</p>' b.save() context = Context({'page': a}) template = Template(html_to_template_text(a.content, context)) html = template.render(context) self.assertEqual(html, '<div><p>Some text</p></div>')
def test_inline_scss(self): template = Template(""" {% load scss %} {% inlinescss %} $the-border: 1px; #bordered { border: $the-border * 2; } {% endinlinescss %} """) rendered = """#bordered { border: 2px; }""" self.assertEqual(template.render(RequestContext({})).strip(), rendered)
def test_external_less(self): template = Template(""" {% load less %} {% less "styles/test.less" %} """) compiled_filename_re = re.compile(r"LESS_CACHE/styles/test-[a-f0-9]{12}.css") compiled_filename = template.render(RequestContext({})).strip() self.assertTrue(bool(compiled_filename_re.match(compiled_filename))) compiled_path = os.path.join(self.django_settings.MEDIA_ROOT, compiled_filename) compiled_content = open(compiled_path).read().strip() compiled = """#header h1 { background-image: url('/media/images/header.png'); }""" self.assertEquals(compiled_content, compiled) # Change the modification time source_path = os.path.join(self.django_settings.MEDIA_ROOT, "styles/test.less") os.utime(source_path, None) # The modification time is cached so the compiled file is not updated compiled_filename_2 = template.render(RequestContext({})).strip() self.assertTrue(bool(compiled_filename_re.match(compiled_filename_2))) self.assertEquals(compiled_filename, compiled_filename_2) # Wait to invalidate the cached modification time time.sleep(self.django_settings.LESS_MTIME_DELAY) # Now the file is re-compiled compiled_filename_3 = template.render(RequestContext({})).strip() self.assertTrue(bool(compiled_filename_re.match(compiled_filename_3))) self.assertNotEquals(compiled_filename, compiled_filename_3) # Check that we have only one compiled file, old files should be removed compiled_file_dir = os.path.dirname(os.path.join(self.django_settings.MEDIA_ROOT, compiled_filename_3)) self.assertEquals(len(os.listdir(compiled_file_dir)), 1)
def get_rendered(post, user): request = self.get_request() request.user = user ForumPermissionMiddleware().process_request(request) t = Template( self.loadstatement + '{% get_permission \'can_delete_post\' post request.user as user_can_delete_post %}' '{% if user_can_delete_post %}CAN_DELETE{% else %}CANNOT_DELETE{% endif %}' ) c = Context({'post': post, 'request': request}) rendered = t.render(c) return rendered
def test_link_nofollow(self): # Regular page = Page(name='Explore', region=self.region) rf = RequestFactory() request = rf.get('/') content = ('<p><a href="http://example.org/">hi</a></p>') template = Template(""" {% load pages_tags %} {% render_plugins content %} """) rendered = template.render( Context({ 'region': self.region, 'request': request, 'content': content, 'page': page })) self.failUnless('http://example.org/' in rendered) self.assertTrue('nofollow' not in rendered) # Nofollow page = Page(name='Explore', region=self.region) rf = RequestFactory() request = rf.get('/') content = ('<p><a href="http://example.org/">hi</a></p>') template = Template(""" {% load pages_tags %} {% render_plugins_nofollow content %} """) rendered = template.render( Context({ 'region': self.region, 'request': request, 'content': content, 'page': page })) self.failUnless('http://example.org/' in rendered) self.assertTrue('nofollow' in rendered)
def test_embed_with_query_multiple_list(self): # Test multiple KEY=VALUE arguments where the key is repeated multiple # times (this is valid in a URL query). template = Template(""" {% load embed_video_tags %} {% video 'http://www.youtube.com/watch?v=jsrRJyHBvzw' rel=0 loop=1 end=5 end=6 %} """) expected = { 'rel': ['0'], 'loop': ['1'], 'end': ['5', '6'], 'wmode': ['opaque'] } self._validate_GET_query(template.render(self._grc()), expected)
def db_ins(): p = Person() p.addr = '跑马巷' p.age = 28 p.name = 'panda' p.save() p1 = Person(name='panda_fly', addr='张府园', age=19) p1.save() t = Template("<h1>增 : res {{s_res}}</h1>") c = Context({"s_res": "Ins success"}) res = HttpResponse(t.render(c)) return res
def test_inline_less(self): template = Template(""" {% load less %} {% inlineless %} @the-border: 1px; #bordered { border: @the-border * 2; } {% endinlineless %} """) rendered = """#bordered { border: 2px; }""" self.assertEqual(template.render(self._get_request_context()).strip(), rendered)
def task_state_change_update(task, state_change_description): t = Template(""" {{task.responsible.get_full_name|default:task.responsible.username}} {{state_change_description}} :\n "{{task.goal_description}} "\nאושר על ידי {{task.closed_by.get_full_name|default:task.closed_by.username}} """) trunkated_subject_and_detailes = t.render(Context({"task": task, 'state_change_description': state_change_description})) discussion_task_email_updates( task, trunkated_subject_and_detailes, task.closed_by, trunkated_subject_and_detailes)
def test_non_ascii_content(self): template = Template(""" {% load less %} {% less "styles/non-ascii.less" %} """) compiled_filename = template.render(self._get_request_context()).strip() compiled_path = os.path.join(self.django_settings.STATIC_ROOT, compiled_filename) compiled_content = open(compiled_path).read().strip() compiled = """.external_link:first-child:before { content: "Zobacz także:"; background: url('/static/styles/картинка.png'); }""" self.assertEquals(compiled_content, compiled)
def get_main_template(self, include: list([str]), arguments: list([str]), solution: str): includes = "\n".join(include) arguments = ", ".join(arguments) raw_template = self.template_code.get("main") template = Template(raw_template) context = Context({ "includes": includes, "arguments": arguments, "solution": solution }) template_code = template.render(context) return template_code
def test_page_attribute_tag_escapes_content(self): script = '<script>alert("XSS");</script>' class FakePage(object): def get_page_title(self, *args, **kwargs): return script class FakeRequest(object): current_page = FakePage() REQUEST = {'language': 'en'} request = FakeRequest() template = Template('{% load cms_tags %}{% page_attribute page_title %}') context = Context({'request': request}) output = template.render(context) self.assertNotEqual(script, output) self.assertEqual(escape(script), output)
def test_inline_coffeescript(self): template = Template(""" {% load coffeescript %} {% inlinecoffeescript %} console.log "Hello, World" {% endinlinecoffeescript %} """) rendered = """(function() { console.log("Hello, World"); }).call(this);""" self.assertEqual( self._clean_javascript( template.render(self._get_request_context()).strip()), self._clean_javascript(rendered))
def discussion_add_feedback(discussion, user, feedbabk_type = None, content = None, voice_recording = None): if feedbabk_type == None: return None, 'No feedback type' if feedbabk_type != Feedback.ADVICE and feedbabk_type != Feedback.COOPERATION and feedbabk_type != Feedback.INTUITION and feedbabk_type != Feedback.ENCOURAGE: return None,( 'Wrong feedback type ' + str(feedbabk_type)) if False == discussion.can_user_access_discussion(user): return None, "user cannot access discussion" # if not discussion.is_active(): # return None, "discussion is not active" if user == discussion.owner: return None, "discussion owner cannot post a feedback" if Feedback.objects.filter( discussion = discussion, feedbabk_type = feedbabk_type, content = content, user = user).count() != 0: return None, "feedback already exists" feedback = Feedback(discussion=discussion, user=user, feedbabk_type=feedbabk_type, content=content, voice_recording = voice_recording) feedback.full_clean() feedback.save() discussion.save() #verify that the entire discussion is considered updated success, error_string = start_discussion_following( discussion, user) if success == False: return None, error_string t = Template(""" {{feedbabk.user.get_full_name|default:feedbabk.user.username}} פירסם/ה {{feedbabk.get_feedbabk_type_name}}:\n "{{feedbabk.content}} "\n """) trunkated_subject_and_detailes = t.render(Context({"feedbabk": feedback})) discussion_email_updates(discussion, trunkated_subject_and_detailes, user, trunkated_subject_and_detailes) user_posted_a_feedback_in_another_other_user_s_discussion(user, feedback.get_absolute_url()) return feedback, None
def test_lookup_in_staticfiles_dirs(self): template = Template(""" {% load less %} {% less "another_test.less" %} """) compiled_filename_re = re.compile( r"LESS_CACHE/another_test-[a-f0-9]{12}.css") compiled_filename = template.render( self._get_request_context()).strip() self.assertTrue(bool(compiled_filename_re.match(compiled_filename))) compiled_path = os.path.join(self.django_settings.STATIC_ROOT, compiled_filename) compiled_content = open(compiled_path).read().strip() compiled = """#header-from-staticfiles-dir h1 { color: red; }""" self.assertEquals(compiled_content, compiled) template = Template(""" {% load less %} {% less "prefix/another_test.less" %} """) compiled_filename_re = re.compile( r"LESS_CACHE/prefix/another_test-[a-f0-9]{12}.css") compiled_filename = template.render( self._get_request_context()).strip() self.assertTrue(bool(compiled_filename_re.match(compiled_filename))) compiled_path = os.path.join(self.django_settings.STATIC_ROOT, compiled_filename) compiled_content = open(compiled_path).read().strip() compiled = """#header-from-staticfiles-dir-with-prefix h1 { color: red; }""" self.assertEquals(compiled_content, compiled)
def render(self, request, template_args, **kwargs): """ Render depending on the request and node """ if kwargs['ext'] in ('', '/'): template_ext = '.html' else: template_ext = kwargs['ext'] template_args['messages'] = [] from django.contrib.messages import get_messages storage = get_messages(request) for message in storage: template_args['messages'].append(message) if request.path in ('', '/') and not kwargs.get( 'template') and request_switch.interface: t = Template(request_switch.interface.content) template_ext = '.html' context = RequestContext(request, template_args) return HttpResponse( t.render(context), content_type=mimetypes.guess_type('filename' + template_ext)[0]) else: from django.template import loader t = loader.select_template( (kwargs.get('template', 'actions/' + kwargs['action'] + template_ext), '200' + template_ext, 'ilot/200' + template_ext)) return HttpResponse( t.render(template_args, request), content_type=mimetypes.guess_type('filename' + template_ext)[0])
def render(tag_library, tag_str, context=None): context = context or {} if not isinstance(context, Context): context = Context(context) contribute_to_context(context) string = '{%% load %s %%}{%% %s %%}' % (tag_library, tag_str) template = Template(string) if VERSION >= (1, 11): # Prevent "TypeError: 'NoneType' object is not iterable" in get_exception_info template.nodelist[1].token.position = (0, 0) return template.render(context)
def db_n2_1(): entry1 = Entry.objects.create(name="e1") entry2 = Entry.objects.create(name="e2") emp1 = Employee.objects.create(name="emp1", entry=entry1) emp2 = Employee.objects.create(name="emp2", entry=entry2) emp3 = Employee.objects.create(name="emp3", entry=entry2) print "emp1 id : ", emp1.entry print "e2 ins : ", entry2.employee_set.all() print "e1 ins : ", entry1.employee_set.all() t = Template("<h1>多对一 : res {{s_res}}</h1>") c = Context({"s_res": "More 2 one success"}) res = HttpResponse(t.render(c)) return res
def db_del(): obj_name = 'panda_fly' ps = Person.objects.filter(name=obj_name) if (len(ps) > 1): # 删整行 # Person.objects.filter(name=obj_name).delete() Person.objects.filter(name=obj_name)[0].delete() elif (len(ps) == 1): # 删一行 Person.objects.get(name=obj_name).delete() t = Template("<h1>删: res {{s_res}}</h1>") c = Context({"s_res": "Del success"}) res = HttpResponse(t.render(c)) return res
def test_include_plugin_utf8(self): a = Page(name='Front Page') a.content = (u'<a class="plugin includepage" ' u'href="青平台基金會">dummy</a>') a.save() b = Page(name=u'青平台基金會') b.content = u'<p>青平台基金會</p>' b.save() context = Context({'page': a}) template = Template(html_to_template_text(a.content, context)) html = template.render(context) self.assertEqual(html, u'<div class="included_page_wrapper">' u'<p>青平台基金會</p></div>')
def test_cached_show_placeholder_sekizai(self): from django.core.cache import cache cache.clear() from cms.test_utils import project template_dir = os.path.join(os.path.dirname(project.__file__), 'templates', 'alt_plugin_templates', 'show_placeholder') page = create_page('Test', 'col_two.html', 'en') placeholder = page.placeholders.all()[0] add_plugin(placeholder, TextPlugin, 'en', body='HIDDEN') request = RequestFactory().get('/') request.user = self.get_staff_user_with_no_permissions() request.current_page = page if DJANGO_1_7: override = {'TEMPLATE_DIRS': [template_dir], 'CMS_TEMPLATES': []} else: override = {'TEMPLATES': deepcopy(settings.TEMPLATES)} override['TEMPLATES'][0]['DIRS'] = [template_dir] with self.settings(**override): template = Template( "{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'en' 1 %}{% render_block 'js' %}" ) context = RequestContext(request, { 'page': page, 'slot': placeholder.slot }) output = template.render(context) self.assertIn('JAVASCRIPT', output) context = RequestContext(request, { 'page': page, 'slot': placeholder.slot }) output = template.render(context) self.assertIn('JAVASCRIPT', output)
def _base_detail( request, instance, template_name='detail.html', item_name="char_1", template_string='', ): context = RequestContext(request) context['instance'] = instance context['item_name'] = item_name if template_string: template = Template(template_string) return HttpResponse(template.render(context)) else: return render_to_response(template_name, context)
def test_cached_show_placeholder_preview(self): from django.core.cache import cache cache.clear() page = create_page('Test', 'col_two.html', 'en', published=True) placeholder = page.placeholders.all()[0] add_plugin(placeholder, TextPlugin, 'en', body='<b>Test</b>') request = RequestFactory().get('/') user = User(username="******", password="******", is_superuser=True, is_staff=True, is_active=True) user.save() request.current_page = page.publisher_public request.user = user template = Template( "{% load cms_tags %}{% show_placeholder slot page 'en' 1 %}") context = RequestContext(request, { 'page': page, 'slot': placeholder.slot }) with self.assertNumQueries(5): output = template.render(context) self.assertIn('<b>Test</b>', output) add_plugin(placeholder, TextPlugin, 'en', body='<b>Test2</b>') request = RequestFactory().get('/?preview') request.current_page = page request.user = user context = RequestContext(request, { 'page': page, 'slot': placeholder.slot }) with self.assertNumQueries(5): output = template.render(context) self.assertIn('<b>Test2</b>', output)