def test_nested_plugins_language_fallback(self):
""" Tests language_fallback placeholder configuration for nested plugins"""
page_en = create_page('page_en', 'col_two.html', 'en')
title_de = create_title("de", "page_de", page_en)
placeholder_en = page_en.placeholders.get(slot='col_left')
placeholder_de = title_de.page.placeholders.get(slot='col_left')
link_en = add_plugin(placeholder_en,
LinkPlugin,
'en',
name='en name',
url='http://example.com/en')
add_plugin(placeholder_en,
TextPlugin,
'en',
target=link_en,
body='en body')
context_en = SekizaiContext()
context_en['request'] = self.get_request(language="en", page=page_en)
context_de = SekizaiContext()
context_de['request'] = self.get_request(language="de", page=page_en)
conf = {
'col_left': {
'language_fallback': True,
},
}
with self.settings(CMS_PLACEHOLDER_CONF=conf):
content_de = _render_placeholder(placeholder_de, context_de)
self.assertRegexpMatches(content_de,
"<a href=\"http://example.com/en\"")
self.assertRegexpMatches(content_de, "en body")
context_de2 = SekizaiContext()
request = self.get_request(language="de", page=page_en)
request.user = self.get_superuser()
request.toolbar = CMSToolbar(request)
request.toolbar.edit_mode = True
context_de2['request'] = request
del (placeholder_de._plugins_cache)
cache.clear()
content_de2 = _render_placeholder(placeholder_de, context_de2)
self.assertFalse("en body" in content_de2)
# remove the cached plugins instances
del (placeholder_de._plugins_cache)
cache.clear()
# Then we add a plugin to check for proper rendering
link_de = add_plugin(placeholder_en,
LinkPlugin,
'de',
name='de name',
url='http://example.com/de')
add_plugin(placeholder_en,
TextPlugin,
'de',
target=link_de,
body='de body')
content_de = _render_placeholder(placeholder_de, context_de)
self.assertRegexpMatches(content_de,
"<a href=\"http://example.com/de\"")
self.assertRegexpMatches(content_de, "de body")
def render_tag(self, context, *args, **kwargs):
"""Return the result from cache or fresh."""
self.template_tag_args = args
self.template_tag_kwargs = kwargs
self.cache_key = self.get_cache_key(self.template_tag_kwargs)
self.add_blocks(context)
if not self.cached:
sub_context = SekizaiContext(self.fetch_data(context))
rendered_data = self.render_template()
rendered_data = self.post_render(context, sub_context,
rendered_data)
return rendered_data
cached_data = self.load_from_cache()
if cached_data:
return cached_data
else:
sub_context = SekizaiContext(self.fetch_data(context))
rendered_data = self.render_template(sub_context)
rendered_data = self.post_render(context, sub_context,
rendered_data)
self.save_to_cache(rendered_data)
return rendered_data
def test_add_review(self):
reviewtext = self.make_random_hash()
reviewtext2 = self.make_random_hash()
#test 1 review
review = G(Review, status=Review.STATUS.active)
subscriber = review.subscriber
review.comment = reviewtext
review.save()
t = Template(
'{% load components_maker %}{% reviewscomponent subscriber 5 %}')
c = SekizaiContext({"subscriber": subscriber})
html = t.render(c)
self.assertIn(reviewtext, html)
#add another review to same subscriber
review2 = G(Review, status=Review.STATUS.active)
review2.comment = reviewtext2
review2.subscriber = subscriber
review2.save()
t2 = Template(
'{% load components_maker %}{% reviewscomponent subscriber 5 %}')
c2 = SekizaiContext({"subscriber": subscriber})
html2 = t2.render(c2)
self.assertIn(reviewtext, html2)
self.assertIn(reviewtext2, html2)
def test_plugins_language_fallback(self):
""" Tests language_fallback placeholder configuration """
page_en = create_page('page_en', 'col_two.html', 'en')
title_de = create_title("de", "page_de", page_en)
placeholder_en = page_en.placeholders.get(slot='col_left')
placeholder_de = title_de.page.placeholders.get(slot='col_left')
add_plugin(placeholder_en, 'TextPlugin', 'en', body='en body')
context_en = SekizaiContext()
context_en['request'] = self.get_request(language="en", page=page_en)
context_de = SekizaiContext()
context_de['request'] = self.get_request(language="de", page=page_en)
# First test the default (fallback) behavior)
## English page should have the text plugin
content_en = _render_placeholder(placeholder_en, context_en)
self.assertRegexpMatches(content_en, "^en body$")
## Deutsch page have text due to fallback
content_de = _render_placeholder(placeholder_de, context_de)
self.assertRegexpMatches(content_de, "^en body$")
self.assertEqual(len(content_de), 7)
conf = {
'col_left': {
'language_fallback': False,
},
}
# configure non fallback
with self.settings(CMS_PLACEHOLDER_CONF=conf):
## Deutsch page should have no text
del(placeholder_de._plugins_cache)
cache.clear()
content_de = _render_placeholder(placeholder_de, context_de)
## Deutsch page should inherit english content
self.assertNotRegex(content_de, "^en body$")
context_de2 = SekizaiContext()
request = self.get_request(language="de", page=page_en)
request.session['cms_edit'] = True
request.user = self.get_superuser()
request.toolbar = CMSToolbar(request)
context_de2['request'] = request
del(placeholder_de._plugins_cache)
cache.clear()
content_de2 = _render_placeholder(placeholder_de, context_de2)
self.assertFalse("en body" in content_de2)
# remove the cached plugins instances
del(placeholder_de._plugins_cache)
cache.clear()
# Then we add a plugin to check for proper rendering
add_plugin(placeholder_de, 'TextPlugin', 'de', body='de body')
content_de = _render_placeholder(placeholder_de, context_de)
self.assertRegexpMatches(content_de, "^de body$")
def test_render_placeholderfield_cache_in_custom_model(self):
"""
Regression test for #6912
Assert that placeholder of a placeholderfield in custom model has its cache cleared correctly when mark_as_dirty is called in the admin
"""
invalidate_cms_page_cache()
# Create an instance of a custom model containing a placeholderfield
ex = Example1(char_1="one", char_2="two", char_3="tree", char_4="four")
ex.save()
ph1 = ex.placeholder
# Add a first plugin
test_plugin = add_plugin(ph1, "TextPlugin", "en", body="Some text")
test_plugin.save()
# Create a first request using render_placeholder to ensure that the content is equal to the first plugin content
request = self.get_request()
content_renderer = self.get_content_renderer(request)
context = SekizaiContext()
context["request"] = self.get_request()
text = content_renderer.render_placeholder(ph1, context, use_cache=True)
self.assertEqual(text, "Some text")
# Add a second plugin in the placeholder
test_plugin = add_plugin(ph1, "TextPlugin", "en", body="Some other text")
test_plugin.save()
# Clear plugins cache to ensure that cms.utils.plugins.get_plugins() will refetch the plugins
del ph1._plugins_cache
# Create a second request using render_placeholder to ensure that the content is still equal to the first plugin content as cache was not cleared yet
request = self.get_request()
content_renderer = self.get_content_renderer(request)
context = SekizaiContext()
context["request"] = self.get_request()
text = content_renderer.render_placeholder(ph1, context, use_cache=True)
self.assertEqual(text, "Some text")
# Mark placeholder as dirty as it is done in cms.admin.placeholderadmin file
ph1.mark_as_dirty("en", clear_cache=False)
# Create a last request to ensure that rendered content contains the two plugins content
request = self.get_request()
content_renderer = self.get_content_renderer(request)
context = SekizaiContext()
context["request"] = self.get_request()
text = content_renderer.render_placeholder(ph1, context, use_cache=True)
self.assertEqual(text, "Some textSome other text")
def get_search_data(self, obj, language, request):
current_page = obj.page
MAX_CHARS = 1024 * 400 # 400 kb text
text_bits = []
context = SekizaiContext(request)
context["request"] = request
placeholders = self.get_page_placeholders(current_page)
for placeholder in placeholders:
text_bits.append(
strip_tags(render_placeholder(context, placeholder)[:MAX_CHARS])
)
page_meta_description = current_page.get_meta_description(
fallback=False, language=language
)
if page_meta_description:
text_bits.append(page_meta_description)
page_meta_keywords = getattr(current_page, "get_meta_keywords", None)
if callable(page_meta_keywords):
text_bits.append(page_meta_keywords())
return clean_join(" ", text_bits)
def placeholder_html(placeholder, request, language):
if hasattr(placeholder, '_plugins_cache'):
del placeholder._plugins_cache
context = SekizaiContext({'request': request})
renderer = ContentRenderer(request)
return renderer.render_placeholder(placeholder, context,
language=language).strip()
def render(self, context, instance, placeholder):
request = context['request']
if request.method == 'POST' and "cmsplugin_events_register_" + str(
instance.id) in request.POST.keys():
EventRegistry.from_request(request)
context.update({'submitted': True})
else:
events = None
if instance.current_month_filter:
if instance.category_filter:
events = Event.month.find_by_category(
instance.category_filter)
else:
events = Event.month.find()
elif instance.month_filter:
if instance.category_filter:
events = Event.month.find_by_category(
instance.category_filter, instance.month_filter)
else:
events = Event.month.find(instance.month_filter)
elif instance.category_filter:
events = Event.by_category.find(instance.category_filter)
else:
events = Event.ongoing.all()
uctx = SekizaiContext({'events': events})
context.update(uctx)
return super(EventRegistrationPlugin,
self).render(context, instance, placeholder)
def test_placeholder_or_in_edit_mode(self):
"""
Tests the {% placeholder or %} templatetag in edit mode.
"""
t = u'{% load cms_tags %}' + \
u'|{% placeholder "empty" or %}No content{% endplaceholder %}'
superuser = self.get_superuser()
with self.login_user_context(superuser):
endpoint = self.test_page.get_absolute_url() + '?edit'
request = self.get_request(endpoint, page=self.test_page)
request.session['cms_edit'] = True
request.toolbar = CMSToolbar(request)
renderer = self.get_content_renderer(request)
context = SekizaiContext()
context['cms_content_renderer'] = renderer
placeholder = self.test_page.placeholders.get(slot='empty')
expected = renderer.render_placeholder(
placeholder,
context=context,
language='en',
page=self.test_page,
editable=True,
)
expected = u'|{}No content'.format(expected)
rendered = self.render(self.test_page, template=t, request=request)
self.assertEqual(rendered, self.strip_rendered(expected))
def server_error(request, template_name=ERROR_500_TEMPLATE_NAME):
"""
500 error handler which works with django-sekizai
Templates: :template:`500.html`
Context: None
"""
html = '<h1>Server Error (500)</h1>'
try:
template = loader.get_template(template_name)
except TemplateDoesNotExist:
if template_name != ERROR_500_TEMPLATE_NAME:
# Reraise if it's a missing custom template.
raise
template = None
if template:
try:
# Only Django templates guaranteed to work here.
context = SekizaiContext()
html = template.template.render(context)
except Exception:
try:
html = template.render()
except Exception:
pass
return http.HttpResponseServerError(html, content_type='text/html')
def test_render_placeholder_cache(self):
"""
Regression test for #4223
Assert that placeholder cache is cleared correctly when a plugin is saved
"""
invalidate_cms_page_cache()
ex = Example1(char_1='one', char_2='two', char_3='tree', char_4='four')
ex.save()
ph1 = ex.placeholder
###
# add the test plugin
##
test_plugin = add_plugin(ph1, u"TextPlugin", u"en", body="Some text")
test_plugin.save()
request = self.get_request()
content_renderer = self.get_content_renderer(request)
# asserting initial text
context = SekizaiContext()
context['request'] = self.get_request()
text = content_renderer.render_placeholder(ph1, context)
self.assertEqual(text, "Some text")
# deleting local plugin cache
del ph1._plugins_cache
test_plugin.body = 'Other text'
test_plugin.save()
# plugin text has changed, so the placeholder rendering
text = content_renderer.render_placeholder(ph1, context)
self.assertEqual(text, "Other text")
def test_plugins_discarded_with_language_fallback(self):
"""
Tests side effect of language fallback: if fallback enabled placeholder
existed, it discards all other existing plugins
"""
page_en = create_page('page_en', 'col_two.html', 'en')
create_title("de", "page_de", page_en)
placeholder_sidebar_en = page_en.placeholders.get(slot='col_sidebar')
placeholder_en = page_en.placeholders.get(slot='col_left')
add_plugin(placeholder_sidebar_en, 'TextPlugin', 'en', body='en body')
context_en = SekizaiContext()
context_en['request'] = self.get_request(language="en", page=page_en)
conf = {
'col_left': {
'language_fallback': True,
},
}
with self.settings(CMS_PLACEHOLDER_CONF=conf):
# call assign plugins first, as this is what is done in real cms life
# for all placeholders in a page at once
assign_plugins(context_en['request'],
[placeholder_sidebar_en, placeholder_en], 'col_two.html')
# if the normal, non fallback enabled placeholder still has content
content_en = _render_placeholder(placeholder_sidebar_en, context_en)
self.assertRegexpMatches(content_en, "^en body$")
# remove the cached plugins instances
del(placeholder_sidebar_en._plugins_cache)
cache.clear()
def test_watcher_add_namespace(self):
context = SekizaiContext()
watcher = Watcher(context)
varname = get_varname()
context[varname]['key'].append('value')
changes = watcher.get_changes()
self.assertEqual(changes, {'key': ['value']})
def test_placeholder_name_toolbar(self):
placeholder_conf_name = 'test_placeholder'
placeholder_conf_tag = '<div class="cms_placeholder-title">%s</div>' % placeholder_conf_name
with SettingsOverride(
CMS_PLACEHOLDER_CONF={'test': {
'name': placeholder_conf_name
}}):
placeholder = Placeholder()
placeholder.slot = 'test'
placeholder.pk = placeholder.id = 99
context = SekizaiContext()
context['request'] = AttributeObject(
REQUEST={'language': 'en'},
GET=[],
session={},
path='/',
user=self.test_user,
current_page=None,
method='GET',
)
classes = [
"cms_placeholder-bar-%s" % placeholder.pk,
"cms_placeholder_slot::test",
]
output = render_placeholder_toolbar(placeholder, context, '',
'test')
self.assertTrue(
placeholder_conf_tag in output,
'placeholder name %r is not in %r' %
(placeholder_conf_name, output))
def test_placeholder_render_ghost_plugin(self):
"""
Tests a placeholder won't render a ghost plugin.
"""
page_en = create_page('page_en', 'col_two.html', 'en')
placeholder_en = page_en.placeholders.get(slot='col_left')
CMSPlugin.objects.create(
language='en',
plugin_type='LinkPlugin',
position=1,
placeholder=placeholder_en,
parent=None,
)
add_plugin(
placeholder_en,
"LinkPlugin",
"en",
name='name',
external_link='http://example.com/',
)
context_en = SekizaiContext()
context_en['request'] = self.get_request(language="en", page=page_en)
content_en = _render_placeholder(placeholder_en, context_en)
self.assertEqual(content_en.strip(), '<a href="http://example.com/">name</a>')
def diff(self, request, **kwargs):
# deprecated diff view (used in the PageRevisionForm)
# deprecated because it was only able to show an html code difference
# which compares a revision to a page
# -> REPLACED BY diff-view
pk = kwargs.pop('pk')
page_revision = PageRevision.objects.get(id=pk)
prc = PageRevisionComparator(page_revision, request=request)
slot_html = {
slot: revert_escape(html)
for slot, html in prc.slot_html.items()
if slot in prc.changed_slots
}
if not slot_html:
messages.info(
request,
_(u'No diff between revision and current page detected'))
return self.changelist_view(request, **kwargs)
context = SekizaiContext({
'title':
_(u'Diff current page and page revision #{pk}').format(pk=pk),
'slot_html':
slot_html,
'is_popup':
True,
'page_revision_id':
page_revision.pk,
'request':
request
})
return render(request, self.diff_template, context=context)
def prepare_text(self, obj):
request = get_request(obj.language)
context = SekizaiContext(request)
if 'request' not in context:
context['request'] = request
renderer = request.toolbar.content_renderer
return ' '.join(self._render_plugins(obj, context, renderer))
def test_plugins_prepopulate(self):
""" Tests prepopulate placeholder configuration """
conf = {
'col_left': {
'default_plugins' : [
{
'plugin_type':'TextPlugin',
'values':{'body':'<p>en default body 1</p>'},
},
{
'plugin_type':'TextPlugin',
'values':{'body':'<p>en default body 2</p>'},
},
]
},
}
with self.settings(CMS_PLACEHOLDER_CONF=conf):
page = create_page('page_en', 'col_two.html', 'en')
placeholder = page.placeholders.get(slot='col_left')
context = SekizaiContext()
context['request'] = self.get_request(language="en", page=page)
# Our page should have "en default body 1" AND "en default body 2"
content = _render_placeholder(placeholder, context)
self.assertRegexpMatches(content, "^<p>en default body 1</p>\s*<p>en default body 2</p>$")
def view_revision(self, request, **kwargs):
# render a page for a popup in an old revision
revision_pk = kwargs.pop('revision_pk')
language = request.GET.get('language')
page_version = PageVersion.objects.get(id=revision_pk)
# check if the current user may view the revision
# -> if the user may see the page
user = get_current_user()
if not user_can_view_page(user, page_version.draft):
messages.error(request, _('Missing permission to view this page.'))
prev = request.META.get('HTTP_REFERER')
if prev:
return redirect(prev)
else:
raise Http404
page_absolute_url = page_version.hidden_page.get_draft_url(
language=language)
context = SekizaiContext({
'render_page': page_version.hidden_page,
'page_version': page_version,
'is_popup': False,
'request': request,
'page_absolute_url': page_absolute_url
})
return render(request, self.view_revision_template, context=context)
def test_strip(self):
tpl = template.Template("""
{% load sekizai_tags %}
{% addtoblock 'a' strip %} test{% endaddtoblock %}
{% addtoblock 'a' strip %}test {% endaddtoblock %}
{% render_block 'a' %}""")
context = SekizaiContext()
output = tpl.render(context)
self.assertEqual(output.count('test'), 1, output)
def test_processor(self):
tpl = template.Template("""
{% load sekizai_tags %}
{% addtoblock "ng-config" %}[function() { /* foo */ }]{% endaddtoblock %}
{% render_block "ng-config" postprocessor "djng.sekizai_processors.module_config" %}
""")
context = SekizaiContext()
output = tpl.render(context)
self.assertIn('.config([function() { /* foo */ }])', output.strip())
def test_processor_module_list(self):
tpl = template.Template("""
{% load sekizai_tags %}
{% addtoblock "ng-requires" %}ngAnimate{% endaddtoblock %}
{% render_block "ng-requires" postprocessor "djng.sekizai_processors.module_list" %}
""")
context = SekizaiContext()
output = tpl.render(context)
self.assertIn('ngAnimate', output.strip())
def render_page_placeholders(self, page, request):
new_request = copy(request)
setattr(new_request, 'current_page', page)
content_renderer = ContentRenderer(new_request)
context = SekizaiContext()
context.update({
'lang': self.language,
'current_page': page,
'request': copy(request),
'cms_content_renderer': content_renderer,
})
return {
placeholder.slot: self.render_placeholder(placeholder, context)
for placeholder in page.placeholders.all()
}
def test_change_profile(self):
reviewtext = self.make_random_hash()
#add 1 review
review = G(Review, status=Review.STATUS.active)
subscriber = review.subscriber
review.comment = reviewtext
review.save()
subscriber.vanity_url = "puppies"
subscriber.save()
t = Template(
'{% load components_maker %}{% reviewscomponent subscriber 5 %}')
c = SekizaiContext({"subscriber": subscriber})
html = t.render(c)
self.assertIn(reviewtext, html)
#get old cache key
from member.util import get_template_cache_key
print get_template_cache_key("maker_profile", [subscriber, 1])
print get_template_cache_key("maker_profile", [subscriber.id, 1])
from components.templatetags.components_maker import ReviewsComponent
print ReviewsComponent.get_cache_key(
dict(subscriber=subscriber, size=5))
print ReviewsComponent.get_cache_key(
dict(subscriber=subscriber.id, size=5))
#now change profile description
desc_hash = self.make_random_hash()
subscriber.description = subscriber.description + desc_hash
#now test reviews again
c2 = SekizaiContext({"subscriber": subscriber})
html = t.render(c2)
self.assertIn(reviewtext, html)
#now test template change
response = self.client.get("/by/%s/" % subscriber.vanity_url,
follow=True)
print response
print response.redirect_chain
self.assertEqual(response.status_code, 200)
self.assertIn(desc_hash, response.content)
class TestData(CMSTestCase, CommonTestData):
"""Common test data for app_kulukorvaus tests.
Args:
CMSTestCase: http://docs.django-cms.org/en/latest/how_to/testing.html.
CommonTestData: Defined in prodekoorg.app_utils.test.test_utils
"""
fixtures = ["test_users.json"]
context = SekizaiContext()
@classmethod
def setUpTestData(cls):
User = get_user_model()
cls.test_user1 = User.objects.get(email="*****@*****.**")
cls.test_user2 = User.objects.get(email="*****@*****.**")
cls.another_page = create_page(
title="kulukorvaus",
template=TEMPLATE_INHERITANCE_MAGIC,
language="fi",
created_by=cls.test_user2,
published=True,
login_required=True,
apphook="KulukorvausApphook",
apphook_namespace="app_kulukorvaus",
)
cls.file_mock_pdf = MagicMock(spec=File, name="FileMock")
cls.file_mock_pdf.name = "test.pdf"
cls.file_mock_jpg = MagicMock(spec=File, name="FileMock")
cls.file_mock_jpg.name = "test.jpg"
cls.test_perustiedot_model = KulukorvausPerustiedot.objects.create(
created_by_user=cls.test_user1,
created_by="webbitiimi",
email="*****@*****.**",
phone_number="999888777666",
bank_number="FI239482340924092",
bic="SPANKKI",
sum_overall=1234,
additional_info="Some additional info.",
pdf=cls.file_mock_pdf,
)
cls.test_kulukorvaus_model = Kulukorvaus.objects.create(
info=cls.test_perustiedot_model,
target="Testing",
explanation="Making sure that everything works as expected!",
sum_euros=99.991,
additional_info="Some additional info.",
receipt=cls.file_mock_jpg,
)
super(TestData, cls).setUpTestData()
def test_cms_templates_with_pathsep(self):
from sekizai.context import SekizaiContext
with SettingsOverride(CMS_TEMPLATES=[('subdir/template.html', 'Subdir')
],
DEBUG=True,
TEMPLATE_DEBUG=True):
context = SekizaiContext()
self.assertEqual(
render_to_string('subdir/template.html', context).strip(),
'test')
def test_plugins_non_default_language_fallback(self):
""" Tests language_fallback placeholder configuration """
page_en = create_page('page_en', 'col_two.html', 'en')
create_title("de", "page_de", page_en)
placeholder_en = page_en.placeholders.get(slot='col_left')
placeholder_de = page_en.placeholders.get(slot='col_left')
add_plugin(placeholder_de, 'TextPlugin', 'de', body='de body')
context_en = SekizaiContext()
context_en['request'] = self.get_request(language="en", page=page_en)
context_de = SekizaiContext()
context_de['request'] = self.get_request(language="de", page=page_en)
# First test the default (fallback) behavior)
## Deutsch page should have the text plugin
content_de = _render_placeholder(placeholder_en, context_de)
self.assertRegexpMatches(content_de, "^de body$")
del(placeholder_en._plugins_cache)
cache.clear()
## English page should have no text
content_en = _render_placeholder(placeholder_en, context_en)
self.assertRegexpMatches(content_en, "^de body$")
self.assertEqual(len(content_en), 7)
del(placeholder_en._plugins_cache)
cache.clear()
conf = {
'col_left': {
'language_fallback': False,
},
}
# configure non-fallback
with self.settings(CMS_PLACEHOLDER_CONF=conf):
## English page should have deutsch text
content_en = _render_placeholder(placeholder_en, context_en)
self.assertNotRegex(content_en, "^de body$")
# remove the cached plugins instances
del(placeholder_en._plugins_cache)
cache.clear()
# Then we add a plugin to check for proper rendering
add_plugin(placeholder_en, 'TextPlugin', 'en', body='en body')
content_en = _render_placeholder(placeholder_en, context_en)
self.assertRegexpMatches(content_en, "^en body$")
def test_validate_context(self):
sekizai_ctx = SekizaiContext()
django_ctx = template.Context()
self.assertRaises(template.TemplateSyntaxError, validate_context, django_ctx)
self.assertEqual(validate_context(sekizai_ctx), True)
with SettingsOverride(TEMPLATE_DEBUG=False):
self.assertEqual(validate_context(django_ctx), False)
self.assertEqual(validate_context(sekizai_ctx), True)
bits = ['some content', 'more content', 'final content']
self._test('basic.html', bits, ctxclass=template.Context)
def test_validate_context(self):
sekizai_ctx = SekizaiContext()
django_ctx = template.Context()
self.assertRaises(template.TemplateSyntaxError, validate_context,
django_ctx)
self.assertEqual(validate_context(sekizai_ctx), True)
with update_template_debug(debug=False):
self.assertEqual(validate_context(django_ctx), False)
self.assertEqual(validate_context(sekizai_ctx), True)
bits = ['some content', 'more content', 'final content']
self._test('basic.html', bits, sekizai_context=False)
def assert_override_block(self,
template_name,
block_to_override,
path_to_expect_content,
attribute_if_not_text=None,
element_not_to_find=None,
override_block_with="Hello world!",
context={},
skip=[]):
if block_to_override in skip:
return # without testing anything
template = Template("""
{%% extends "%(template_name)s" %%}
{%% block %(block_to_override)s %%}{%% spaceless %%}
%(override_block_with)s
{%% endspaceless %%}{%% endblock %%}
""" % dict(template_name=template_name,
block_to_override=block_to_override,
override_block_with=override_block_with))
context.setdefault('request', self.fake_request)
html = template.render(SekizaiContext(context))
element = self.query(html, path_to_expect_content)
if attribute_if_not_text is None:
values = [element.text]
values.extend([e.tail for e in element])
value = ",".join([v for v in values if v is not None])
else:
value = element.get(attribute_if_not_text)
if value is None: value = ''
self.assertIn(
override_block_with, value,
"Did not find expected text in correct location (%s) when overriding "
"block '%s' on template '%s'. The complete output was: %s" %
(path_to_expect_content, block_to_override, template_name, html))
if element_not_to_find is not None:
unexpected_matches = self.query(
html,
"%s %s" % (path_to_expect_content, element_not_to_find),
list=True,
required=False)
self.assertEquals(
[], [self.tostring(e) for e in unexpected_matches],
"An element that should have been replaced was found in the "
"rendered page: %s" % element_not_to_find)
return html
