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