def test_user_courses(self):
# instructor that sees both Sample Course & Alternate Course
self.instructor_three = UserFactory(username='******')
self.add_as_faculty(self.sample_course, self.instructor_three)
self.add_as_faculty(self.alt_course, self.instructor_three)
out = Template("{% load user_projects %}"
"{% num_courses for user as user_courses %}"
"{{user_courses}}").render(
Context({'user': self.instructor_three}))
self.assertEqual(out, "2")
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_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_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' %}")
# Default configuration has CMS_HIDE_UNTRANSLATED=False
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/")
context = self.get_context(page_3.get_absolute_url())
context['request'].current_page = page_3
res = tpl.render(context)
self.assertEqual(res, "")
with SettingsOverride(CMS_HIDE_UNTRANSLATED=True):
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/")
context = self.get_context(page_3.get_absolute_url())
context['request'].current_page = page_3
res = tpl.render(context)
self.assertEqual(res, "/de/")
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 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(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(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 test_template_list_is_correct_dict(self):
template_list = {
"t1": Template('a'),
"t2": Template('b'),
"t3": Template('c')
}
base_renderer = BaseRenderer()
base_renderer.templates.update(template_list)
renderer = BaseRenderer(template_list)
self.assertEqual(renderer.templates.keys(),
base_renderer.templates.keys())
for tpl_key in renderer.templates.keys():
try:
renderer._load_template(tpl_key)
except Exception as exc:
self.fail(exc.message)
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_endless_include(self):
""" Should detect endless loops and give an error message
"""
a = Page(name='Front Page', region=self.region)
a.content = '<a class="plugin includepage" href="Front_Page">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.failUnless(
('Unable to include <a href="/test-region/Front_Page">Front Page'
'</a>: endless include loop') in html)
def test_multiple_extend_empty_namespace(self):
context = Context({})
template = Template(
self.template_extend % {'app': 'top-level'}
).render(context)
previous_app = ''
for test_app in ['top-level'] + self.apps:
self.assertTrue(test_app in template)
if previous_app:
self.assertTrue(template.index(test_app) >
template.index(previous_app))
previous_app = test_app
def _add_css_styles(self, epub_book):
"""Adds default css styles and custom css text if exists in config"""
book_css = []
try:
epub_book.add_item(
ebooklib.epub.EpubItem(uid='default.css',
content=self._get_default_style(),
file_name='{}/{}'.format(
STYLES_DIR, 'default.css'),
media_type='text/css'))
book_css.append('default.css')
except Exception as e:
logger.info('Default style was not added %s.', e)
if self.theme_name:
content = self._get_theme_style()
if self.theme_name == 'custom':
try:
data = json.loads(
self.config['theme']['custom'].encode('utf8'))
tmpl = Template(content)
ctx = Context(data)
content = tmpl.render(ctx)
except:
logger.exception("Fails with custom theme.")
item = ebooklib.epub.EpubItem(uid='theme.css',
content=content,
file_name='{}/{}'.format(
STYLES_DIR, 'theme.css'),
media_type='text/css')
epub_book.add_item(item)
book_css.append('theme.css')
# we need to add css from publishing settings screen
settings_style = self.config.get('settings', {}).get('styling', None)
if settings_style:
item = ebooklib.epub.EpubItem(uid='custom_style.css',
content=settings_style,
file_name='{}/{}'.format(
STYLES_DIR, 'custom_style.css'),
media_type='text/css')
epub_book.add_item(item)
book_css.append('custom_style.css')
return book_css
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_embed_with_query_settings_override(self):
# Test KEY=VALUE argument with default values provided by settings
template = Template("""
{% load embed_video_tags %}
{% video 'http://www.youtube.com/watch?v=jsrRJyHBvzw' %}
""")
expected = {
'rel': ['0'],
'stop': ['5'],
}
rendered = template.render(self._grc())
self._validate_GET_query(rendered, expected)
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)
t = Template('{% load cms_tags %}{% static_placeholder "" %}')
rendered = t.render(self.get_context('/'))
self.assertEqual("", rendered)
t = Template('{% load cms_tags %}{% static_placeholder code or %}No Content{% endstatic_placeholder %}')
rendered = t.render(Context({'code': StaticPlaceholder.objects.all()[0]}))
self.assertIn("No Content", rendered)
for p in Placeholder.objects.all():
add_plugin(p, 'TextPlugin', 'en', body='test')
t = Template('{% load cms_tags %}{% static_placeholder "foobar" or %}No Content{% endstatic_placeholder %}')
rendered = t.render(self.get_context('/'))
self.assertNotIn("No Content", rendered)
self.assertEqual(StaticPlaceholder.objects.filter(site_id__isnull=True, code='foobar').count(), 1)
def test_inheritance24(self):
"""
Inheritance from local context without use of template loader
"""
output = render(
'inheritance24', {
'context_template':
Template(
"1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"
)
})
self.assertEqual(output, '1234')
def test_lookup_in_staticfiles_dirs(self):
template = Template("""
{% load coffeescript %}
{% coffeescript "another_test.coffee" %}
""")
compiled_filename_re = re.compile(
r"COFFEESCRIPT_CACHE/another_test-[a-f0-9]{12}.js")
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()
compiled = """(function() {
console.log("Hello, World from STATICFILES_DIRS!");
}).call(this);
"""
self.assertEquals(self._clean_javascript(compiled_content),
self._clean_javascript(compiled))
template = Template("""
{% load coffeescript %}
{% coffeescript "prefix/another_test.coffee" %}
""")
compiled_filename_re = re.compile(
r"COFFEESCRIPT_CACHE/prefix/another_test-[a-f0-9]{12}.js")
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()
compiled = """(function() {
console.log("Hello, World from STATICFILES_DIRS with prefix!");
}).call(this);
"""
self.assertEquals(self._clean_javascript(compiled_content),
self._clean_javascript(compiled))
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_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 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 compress(context, data, name):
"""
Data is the string from the template (the list of js files in this case)
Name is either 'js' or 'css' (the sekizai namespace)
We basically just manually pass the string through the compress template tag
"""
# Handle 'scripts' as js files
name_ = name
if name == "scripts":
name_ = "js"
return CompressorNode(Template(data).nodelist, name_, "file").render({})
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 get_links_content(request):
links_list = Link.objects.all().order_by('order')
template = Template("""
<table>
{% for item in links_list %}
{% cycle '<tr><td>' '<td>'%} <a href="{{ item.url }}">{{ item.title }}</a> {% cycle '</td>' '</td></tr>' %}
{% empty %}
<p>پیوندی یافت نشد.</p>
{% endfor %}
</table>
""")
return template.render(
RequestContext(request, {'links_list': links_list}))
def _clean_body(self, body):
invalid_vars = []
for varnode in Template(body).nodelist.get_nodes_by_type(VariableNode):
varname = varnode.filter_expression.var.var
if varname not in TEMPLATES_VARS:
invalid_vars.append(varname)
if invalid_vars:
raise ValidationError(self.error_messages['invalid_vars'],
params={'vars': invalid_vars},
code='invalid_vars',
)
def _base_detail(request, instance, template_name='detail.html',
item_name="char_1", template_string='',):
context = {}
context['instance'] = instance
context['instance_class'] = instance.__class__()
context['item_name'] = item_name
if hasattr(request, 'toolbar'):
request.toolbar.set_object(instance)
if template_string:
template = Template(template_string)
return HttpResponse(template.render(RequestContext(request=request, dict_=context)))
else:
return render(request, template_name, context)
def get_html():
news_list = News.objects.filter(
archived=False).order_by('-publish_date')
res = Template(u"""
<table style="width: 100%">
{% for item in news_list %}
<tr><td style="width: 80%;"><a href="/news/{{ item.id }}/">{{ item.title }}</a></td><td>{{ item.publish_date_pdate }}</td></tr>
{% empty %}
<p>خبری یافت نشد.</p>
{% endfor %}
</table>
""").render(Context({'news_list': news_list}))
return res
def test_object_not_permitted(self):
tmpl = """
{% if "uneditable" in perm.permitter_test.CanEditObject %}
fail :(
{% else %}
success!
{% endif %}
"""
req = HttpRequest()
req.user = AnonymousUser()
resp = Template(tmpl).render(RequestContext(req))
self.assertFalse('fail' in resp)
self.assertTrue('success!' in resp)
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_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_title_body_message(title, body):
message = Template("""
<div style="direction:rtl;">
<h1>{{title}} </h1>
<p> {{body|safe}}</p>
موسسه نگاه نو
</div>
""").render(Context({
'title': title,
'body': body.replace('\r\n', '<br/>').replace('\n\r', '<br/>').replace('\r', '<br/>').replace('\n', '<br/>')
}))
return mark_safe(message)
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)
