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 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, **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 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 process_request(self, request): # Decide whether the front admin is active for this request. template_rendered.connect(self._store_template_info)
def __enter__(self): template_rendered.connect(self.on_template_render) return self