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)
