def find_all_templates(template_name):
template = loader.get_template(template_name)
templates = {}
def _store_template_info(sender, **kwargs):
template = kwargs['template']
if template.name in settings.TEMPLATES_BLACKLIST:
# We don't show templates that cannot be edited.
return
if not template.name in templates:
# For some reasons the Django/Jinja2 framework might load the same
# templates multiple times.
templates.update({
template.name: {
"name": template.name,
"index": len(templates)
}
})
template_loaded.connect(_store_template_info)
template_rendered.connect(_store_template_info)
try:
template.render()
finally:
template_rendered.disconnect(_store_template_info)
template_loaded.disconnect(_store_template_info)
return templates.values()
def do_request(self, req, status, expect_errors):
# Django closes the database connection after every request;
# this breaks the use of transactions in your tests.
if close_old_connections is not None: # Django 1.6+
signals.request_started.disconnect(close_old_connections)
signals.request_finished.disconnect(close_old_connections)
else: # Django < 1.6
signals.request_finished.disconnect(close_connection)
try:
req.environ.setdefault('REMOTE_ADDR', '127.0.0.1')
# is this a workaround for
# https://code.djangoproject.com/ticket/11111 ?
req.environ['REMOTE_ADDR'] = str(req.environ['REMOTE_ADDR'])
req.environ['PATH_INFO'] = str(req.environ['PATH_INFO'])
auth = req.environ.get('HTTP_AUTHORIZATION')
if auth is None:
req.environ['HTTP_AUTHORIZATION'] = 'None'
elif isinstance(auth, bytes):
req.environ['HTTP_AUTHORIZATION'] = str(auth.decode())
else:
req.environ['HTTP_AUTHORIZATION'] = str(auth)
# Curry a data dictionary into an instance of the template renderer
# callback function.
data = {}
on_template_render = curry(store_rendered_templates, data)
template_rendered.connect(on_template_render)
response = super(JSONAPITestApp,
self).do_request(req, status, expect_errors)
# Add any rendered template detail to the response.
# If there was only one template rendered (the most likely case),
# flatten the list to a single element.
def flattend(detail):
if len(data[detail]) == 1:
return data[detail][0]
return data[detail]
response.context = None
response.template = None
response.templates = data.get('templates', None)
if data.get('context'):
response.context = flattend('context')
if data.get('template'):
response.template = flattend('template')
elif data.get('templates'):
response.template = flattend('templates')
return response
finally:
if close_old_connections: # Django 1.6+
signals.request_started.connect(close_old_connections)
signals.request_finished.connect(close_old_connections)
else: # Django < 1.6
signals.request_finished.connect(close_connection)
def do_request(self, req, status, expect_errors):
# Curry a data dictionary into an instance of the template renderer
# callback function.
data = {}
on_template_render = curry(store_rendered_templates, data)
template_rendered.connect(on_template_render)
response = super(DjangoTestApp,
self).do_request(req, status, expect_errors)
# Add any rendered template detail to the response.
# If there was only one template rendered (the most likely case),
# flatten the list to a single element.
def flattend(detail):
if len(data[detail]) == 1:
return data[detail][0]
return data[detail]
response.context = None
response.template = None
response.templates = data.get('templates', None)
if data.get('context'):
response.context = flattend('context')
if data.get('template'):
response.template = flattend('template')
elif data.get('templates'):
response.template = flattend('templates')
return response
def do_request(self, req, status, expect_errors):
# Curry a data dictionary into an instance of the template renderer
# callback function.
data = {}
on_template_render = curry(store_rendered_templates, data)
template_rendered.connect(on_template_render)
response = super(DjangoTestApp, self).do_request(req, status, expect_errors)
# Add any rendered template detail to the response.
# If there was only one template rendered (the most likely case),
# flatten the list to a single element.
def flattend(detail):
if len(data[detail]) == 1:
return data[detail][0]
return data[detail]
response.context = None
response.template = None
response.templates = data.get('templates', None)
if data.get('context'):
response.context = flattend('context')
if data.get('template'):
response.template = flattend('template')
elif data.get('templates'):
response.template = flattend('templates')
return response
def process_request(self, request):
self.time_started = time.time()
self.templates_used = []
self.contexts_used = []
self.sql_offset_start = len(connection.queries)
template_rendered.connect(self._storeRenderedTemplates)
def process_request(self, request):
if (settings.DEBUG or request.user.is_superuser) and request.REQUEST.has_key('template'):
self.time_started = time.time()
self.templates_used = []
self.contexts_used = []
template_rendered.connect(
self._storeRenderedTemplates
)
def __init__(self, *args: Any, **kwargs: Any) -> None:
DiscoverRunner.__init__(self, *args, **kwargs)
# `templates_rendered` holds templates which were rendered
# in proper logical tests.
self.templates_rendered: Set[str] = set()
# `shallow_tested_templates` holds templates which were rendered
# in `zerver.tests.test_templates`.
self.shallow_tested_templates: Set[str] = set()
template_rendered.connect(self.on_template_rendered)
def do_request(self, req, status, expect_errors):
# Django closes the database connection after every request;
# this breaks the use of transactions in your tests.
if close_old_connections is not None: # Django 1.6+
signals.request_started.disconnect(close_old_connections)
signals.request_finished.disconnect(close_old_connections)
else: # Django < 1.6
signals.request_finished.disconnect(close_connection)
try:
req.environ.setdefault('REMOTE_ADDR', '127.0.0.1')
# is this a workaround for
# https://code.djangoproject.com/ticket/11111 ?
req.environ['REMOTE_ADDR'] = to_string(req.environ['REMOTE_ADDR'])
req.environ['PATH_INFO'] = to_string(req.environ['PATH_INFO'])
# Curry a data dictionary into an instance of the template renderer
# callback function.
data = {}
on_template_render = curry(store_rendered_templates, data)
template_rendered.connect(on_template_render)
response = super(DjangoTestApp, self).do_request(req, status,
expect_errors)
# Add any rendered template detail to the response.
# If there was only one template rendered (the most likely case),
# flatten the list to a single element.
def flattend(detail):
if len(data[detail]) == 1:
return data[detail][0]
return data[detail]
response.context = None
response.template = None
response.templates = data.get('templates', None)
if data.get('context'):
response.context = flattend('context')
if data.get('template'):
response.template = flattend('template')
elif data.get('templates'):
response.template = flattend('templates')
response.__class__ = self.response_class
return response
finally:
if close_old_connections: # Django 1.6+
signals.request_started.connect(close_old_connections)
signals.request_finished.connect(close_old_connections)
else: # Django < 1.6
signals.request_finished.connect(close_connection)
def __init__(self, *args: Any, **kwargs: Any) -> None:
DiscoverRunner.__init__(self, *args, **kwargs)
# `templates_rendered` holds templates which were rendered
# in proper logical tests.
self.templates_rendered = set() # type: Set[str]
# `shallow_tested_templates` holds templates which were rendered
# in `zerver.tests.test_templates`.
self.shallow_tested_templates = set() # type: Set[str]
template_rendered.connect(self.on_template_rendered)
self.database_id = random.randint(1, 10000)
def __init__(self, *args: Any, **kwargs: Any) -> None:
DiscoverRunner.__init__(self, *args, **kwargs)
# `templates_rendered` holds templates which were rendered
# in proper logical tests.
self.templates_rendered = set() # type: Set[str]
# `shallow_tested_templates` holds templates which were rendered
# in `zerver.tests.test_templates`.
self.shallow_tested_templates = set() # type: Set[str]
template_rendered.connect(self.on_template_rendered)
self.database_id = random.randint(1, 10000)
def __init__(self, *args, **kwargs):
# type: (*Any, **Any) -> None
DiscoverRunner.__init__(self, *args, **kwargs)
# `templates_rendered` holds templates which were rendered
# in proper logical tests.
self.templates_rendered = set() # type: Set[str]
# `shallow_tested_templates` holds templates which were rendered
# in `zerver.tests.test_templates`.
self.shallow_tested_templates = set() # type: Set[str]
template_rendered.connect(self.on_template_rendered)
def process_request(self, request):
if not hasattr(request, 'user'):
return
if (settings.DEBUG or request.user.is_superuser) and 'template' in request.REQUEST.keys():
self.time_started = time.time()
self.templates_used = []
self.contexts_used = []
template_rendered.connect(
self._storeRenderedTemplates
)
def templates_used_to_render(self, subject_template, render_context=None):
"""Emulate django.test.client.Client (see request method)."""
from django.test.signals import template_rendered
templates_used = []
def receive_template_signal(sender, template, context, **_kwargs):
templates_used.append(template.name)
template_rendered.connect(receive_template_signal,
dispatch_uid="test_method")
subject_template.render(render_context or Context({}))
template_rendered.disconnect(dispatch_uid="test_method")
return templates_used
def process_request(self, request):
if (settings.DEBUG or request.user.is_superuser) and request.REQUEST.has_key('template'):
self.time_started = time.time()
self.templates_used = []
self.contexts_used = []
if not hasattr(self, 'loghandler'):
self.loghandler = BufferingHandler(1000) # Create and a handler
logging.getLogger('').addHandler(self.loghandler)
else:
self.loghandler.flush() # Empty it of all messages
template_rendered.connect(
self._storeRenderedTemplates
)
def setUp(self):
self.user = User.objects.create(username="******",
email="*****@*****.**")
self.request = Mock()
setattr(self.request, 'user', self.user)
self.order = Order()
self.order.user = self.user
self.order.order_subtotal = decimal.Decimal('10')
self.order.order_total = decimal.Decimal('10')
self.order.shipping_cost = decimal.Decimal('0')
self.order.shipping_address_text = 'shipping address example'
self.order.billing_address_text = 'billing address example'
self.order.save()
self.rendered_templates = []
template_rendered.connect(self.template_rendered_listener)
def do_request(self, req, status, expect_errors):
# Django closes the database connection after every request;
# this breaks the use of transactions in your tests.
signals.request_finished.disconnect(close_connection)
try:
req.environ.setdefault('REMOTE_ADDR', '127.0.0.1')
# is this a workaround for https://code.djangoproject.com/ticket/11111 ?
req.environ['REMOTE_ADDR'] = to_string(req.environ['REMOTE_ADDR'])
req.environ['PATH_INFO'] = to_string(req.environ['PATH_INFO'])
# Curry a data dictionary into an instance of the template renderer
# callback function.
data = {}
on_template_render = curry(store_rendered_templates, data)
template_rendered.connect(on_template_render)
response = super(DjangoTestApp, self).do_request(req, status, expect_errors)
# Add any rendered template detail to the response.
# If there was only one template rendered (the most likely case),
# flatten the list to a single element.
def flattend(detail):
if len(data[detail]) == 1:
return data[detail][0]
return data[detail]
response.context = None
response.template = None
response.templates = data.get('templates', None)
if data.get('context'):
response.context = flattend('context')
if data.get('template'):
response.template = flattend('template')
elif data.get('templates'):
response.template = flattend('templates')
response.__class__ = self.response_class
return response
finally:
signals.request_finished.connect(close_connection)
def setUp(self):
self.old_TEMPLATE_DIRS = settings.TEMPLATE_DIRS
settings.TEMPLATE_DIRS = (
os.path.join(
os.path.dirname(__file__),
'templates'
)
,)
self.user = User.objects.create(username="******")
self.email = "*****@*****.**"
self._old_confirmation_days = app_settings.EMAIL_CONFIRMATION_DAYS
app_settings.EMAIL_CONFIRMATION_DAYS = 14
self.templates = []
self.contexts = []
template_rendered.connect(self._template_rendered)
def setUp(self):
self.user = User.objects.create(
username="******",
email="*****@*****.**")
self.request = Mock()
setattr(self.request, 'user', self.user)
self.order = Order()
self.order.user = self.user
self.order.order_subtotal = decimal.Decimal('10')
self.order.order_total = decimal.Decimal('10')
self.order.shipping_cost = decimal.Decimal('0')
self.order.shipping_address_text = 'shipping address example'
self.order.billing_address_text = 'billing address example'
self.order.save()
self.rendered_templates = []
template_rendered.connect(self.template_rendered_listener)
def do_request(self, req, status, expect_errors):
req.environ.setdefault('REMOTE_ADDR', '127.0.0.1')
# is this a workaround for https://code.djangoproject.com/ticket/11111 ?
req.environ['REMOTE_ADDR'] = to_string(req.environ['REMOTE_ADDR'])
req.environ['PATH_INFO'] = to_string(req.environ['PATH_INFO'])
# Curry a data dictionary into an instance of the template renderer
# callback function.
data = {}
on_template_render = curry(store_rendered_templates, data)
template_rendered.connect(on_template_render)
response = super(DjangoTestApp, self).do_request(req, status, expect_errors)
# Add any rendered template detail to the response.
# If there was only one template rendered (the most likely case),
# flatten the list to a single element.
def flattend(detail):
if len(data[detail]) == 1:
return data[detail][0]
return data[detail]
response.context = None
response.template = None
response.templates = data.get('templates', None)
if data.get('context'):
response.context = flattend('context')
if data.get('template'):
response.template = flattend('template')
elif data.get('templates'):
response.template = flattend('templates')
response.__class__ = DjangoWebtestResponse
return response
def find_all_templates(template_name):
template = loader.get_template(template_name)
templates = {}
def _store_template_info(sender, **kwargs):
template = kwargs['template']
if template.name in settings.TEMPLATES_BLACKLIST:
# We don't show templates that cannot be edited.
return
if not template.name in templates:
# For some reasons the Django/Jinja2 framework might load the same
# templates multiple times.
templates.update({template.name:
{"name": template.name, "index": len(templates)}})
template_loaded.connect(_store_template_info)
template_rendered.connect(_store_template_info)
try:
template.render()
finally:
template_rendered.disconnect(_store_template_info)
template_loaded.disconnect(_store_template_info)
return templates.values()
def setUp(self):
self.rendered = {}
on_template_render = partial(store_rendered_templates, self.rendered)
template_rendered.connect(on_template_render)
self.addCleanup(template_rendered.disconnect, on_template_render)
def __init__(self, *args, **kwargs):
super(TemplatesDebugPanel, self).__init__(*args, **kwargs)
self.templates_used = []
self.contexts_used = []
template_rendered.connect(self._storeRenderedTemplates)
def __init__(self):
self.templates = []
template_rendered.connect(self._storeTemplateInfo)
def enable_instrumentation():
_thread_locals.templates = OrderedDict()
template_loaded.connect(_store_template_info)
template_rendered.connect(_store_template_info)
def enable_instrumentation(self):
template_loaded.connect(self._store_template_info)
template_rendered.connect(self._store_template_info)
def __init__(self, request):
super(TemplateDebugPanel, self).__init__(request)
self.templates = []
template_rendered.connect(self._storeTemplateInfo)
def process_request(self, request):
self.time_started = time.time()
self.templates_used = []
self.contexts_used = []
self.sql_offset_start = len(connection.queries)
template_rendered.connect(self._storeRenderedTemplates)
def setUp(self):
self.templates = []
self.contexts = ContextList()
template_rendered.connect(self.store_rendered_template)
def __init__(self, *args, **kwargs):
super(TemplateDebugPanel, self).__init__(*args, **kwargs)
self.templates = []
template_rendered.connect(self._store_template_info)
def __init__(self, *args, **kwargs):
super(self.__class__, self).__init__(*args, **kwargs)
self.templates = []
template_rendered.connect(self._store_template_info)
def __init__(self, *args, **kwargs):
super(AutoreloadPanel, self).__init__(*args, **kwargs)
self._is_active = True
self.templates = []
template_rendered.connect(self._store_template_info)
def process_request(self, request):
request._frelic = Frelic()
template_rendered.connect(request._frelic.count_templates)
def __init__(self, *args, **kwargs):
super(self.__class__, self).__init__(*args, **kwargs)
self.templates = []
template_rendered.connect(self._store_template_info)
def __init__(self, *args, **kwargs):
super(TemplateDebugPanel, self).__init__(*args, **kwargs)
self.templates = []
template_rendered.connect(self._store_template_info)
def enable_instrumentation(self):
template_loaded.connect(self._store_template_info)
template_rendered.connect(self._store_template_info)
def setUp(self):
self.templates = []
self.contexts = ContextList()
template_rendered.connect(self.store_rendered_template)
def setUp(self):
self.rendered = {}
on_template_render = partial(store_rendered_templates, self.rendered)
template_rendered.connect(on_template_render)
self.addCleanup(template_rendered.disconnect, on_template_render)
def process_request(self, request):
# Decide whether the front admin is active for this request.
template_rendered.connect(self._store_template_info)
def __init__(self, request):
super(TemplateDebugPanel, self).__init__(request)
self.templates = []
template_rendered.connect(self._storeTemplateInfo)
def __enter__(self):
template_rendered.connect(self.on_template_render)
return self
def enable_instrumentation():
_thread_locals.templates = OrderedDict()
template_loaded.connect(_store_template_info)
template_rendered.connect(_store_template_info)
