def process_response(self, response): # If the body is HTML, then we add the toolbar to the response. request = self.request if isinstance(response, WSGIHTTPException): # the body of a WSGIHTTPException needs to be "prepared" response.prepare(request.environ) for panel in self.panels: panel.process_response(response) if response.content_type in self.html_types: static_path = request.static_url(STATIC_PATH) root_path = request.route_url(ROOT_ROUTE_NAME) button_style = get_setting(request.registry.settings, 'button_style', '') vars = { 'panels': self.panels, 'static_path': static_path, 'root_path': root_path, 'button_style': button_style } toolbar_html = render( 'pyramid_debugtoolbar:templates/toolbar.mako', vars, request=request) response_html = response.body toolbar_html = toolbar_html.encode(response.charset or 'utf-8') body = replace_insensitive(response_html, bytes_('</body>'), toolbar_html + bytes_('</body>')) response.app_iter = [body]
def process_response(self, response): # If the body is HTML, then we add the toolbar to the response. request = self.request if isinstance(response, WSGIHTTPException): # the body of a WSGIHTTPException needs to be "prepared" response.prepare(request.environ) for panel in self.panels: panel.process_response(response) if response.content_type in self.html_types: static_path = request.static_url(STATIC_PATH) root_path = request.route_url(ROOT_ROUTE_NAME) button_style = get_setting(request.registry.settings, 'button_style', '') vars = {'panels': self.panels, 'static_path': static_path, 'root_path': root_path, 'button_style': button_style} toolbar_html = render( 'pyramid_debugtoolbar:templates/toolbar.dbtmako', vars, request=request) response_html = response.body toolbar_html = toolbar_html.encode(response.charset or 'utf-8') body = replace_insensitive( response_html, bytes_('</body>'), toolbar_html + bytes_('</body>') ) response.app_iter = [body] response.content_length = len(body)
def test_execute(self): request = self._makeRequest() request.params['cmd'] = 'doit' view = self._makeOne(request) response = view.execute() self.assertEqual(response.body, bytes_('evaled')) self.assertEqual(response.content_type, 'text/html')
def sql_select(self): stmt = self.request.params['sql'] params = self.request.params['params'] engine_id = self.request.params['engine_id'] # Validate hash hash = hashlib.sha1( bytes_(self.request.exc_history.token + stmt + params)).hexdigest() if hash != self.request.params['hash']: raise HTTPBadRequest('Bad token in request') # Make sure it is a select statement if not stmt.lower().strip().startswith('select'): raise HTTPBadRequest('Not a SELECT SQL statement') if not engine_id: raise HTTPBadRequest('No valid database engine') engine = getattr(self.request.registry, 'pdtb_sqla_engines')\ [int(engine_id)]() params = json.loads(params) result = engine.execute(stmt, params) return { 'result': result.fetchall(), 'headers': result.keys(), 'sql': format_sql(stmt), 'duration': float(self.request.params['duration']), }
def process_response(self, response): data = [] for index, query in enumerate(self.queries): stmt = query['statement'] is_select = stmt.strip().lower().startswith('select') params = '' try: params = url_quote(json.dumps(query['parameters'])) except TypeError: pass # object not JSON serializable except UnicodeDecodeError: pass # parameters contain non-utf8 (probably binary) data need = self.token + stmt + params hash = hashlib.sha1(bytes_(need)).hexdigest() data.append({ 'engine_id': query['engine_id'], 'duration': query['duration'], 'sql': format_sql(stmt), 'raw_sql': stmt, 'hash': hash, 'parameters': query['parameters'], 'params': params, 'is_select': is_select, 'context': query['context'], 'query_index': index, }) self.data = { 'queries': data, 'text': text, }
def sql_select(self): stmt = self.request.params["sql"] params = self.request.params["params"] engine_id = self.request.params["engine_id"] # Validate hash hash = hashlib.sha1(bytes_(self.request.exc_history.token + stmt + params)).hexdigest() if hash != self.request.params["hash"]: raise HTTPBadRequest("Bad token in request") # Make sure it is a select statement if not stmt.lower().strip().startswith("select"): raise HTTPBadRequest("Not a SELECT SQL statement") if not engine_id: raise HTTPBadRequest("No valid database engine") engine = getattr(self.request.registry, "pdtb_sqla_engines")[int(engine_id)]() params = json.loads(params) result = engine.execute(stmt, params) return { "result": result.fetchall(), "headers": result.keys(), "sql": format_sql(stmt), "duration": float(self.request.params["duration"]), }
def process_response(self, response): data = [] for query in self.queries: stmt = query['statement'] is_select = stmt.strip().lower().startswith('select') params = '' try: params = url_quote(json.dumps(query['parameters'])) except TypeError: pass # object not JSON serializable except UnicodeDecodeError: pass # parameters contain non-utf8 (probably binary) data need = self.token + stmt + params hash = hashlib.sha1(bytes_(need)).hexdigest() data.append({ 'engine_id': query['engine_id'], 'duration': query['duration'], 'sql': format_sql(stmt), 'raw_sql': stmt, 'hash': hash, 'parameters': query['parameters'], 'params': params, 'is_select': is_select, 'context': query['context'], }) self.data = { 'queries':data, 'text':text, }
def test_source(self): request = self._makeRequest() request.params['frm'] = '0' view = self._makeOne(request) response = view.source() self.assertEqual(response.body, bytes_('source')) self.assertEqual(response.content_type, 'text/html')
def test_source(self): request = self._makeRequest() request.params["frm"] = "0" view = self._makeOne(request) response = view.source() self.assertEqual(response.body, bytes_("source")) self.assertEqual(response.content_type, "text/html")
def test_execute(self): request = self._makeRequest() request.params["frm"] = "0" request.params["cmd"] = "doit" view = self._makeOne(request) response = view.execute() self.assertEqual(response.body, bytes_("evaled")) self.assertEqual(response.content_type, "text/html")
def inject(self, request, response): """ Inject the debug toolbar iframe into an HTML response. """ # called in host app response_html = response.body toolbar_url = debug_toolbar_url(request, request.id) button_style = get_setting(request.registry.settings, 'button_style', '') css_path = request.static_url(STATIC_PATH + 'css/toolbar_button.css') toolbar_html = toolbar_html_template % { 'button_style': button_style, 'css_path': css_path, 'toolbar_url': toolbar_url } toolbar_html = toolbar_html.encode(response.charset or 'utf-8') response.body = replace_insensitive(response_html, bytes_('</body>'), toolbar_html + bytes_('</body>'))
def inject(self, request, response): """ Inject the debug toolbar iframe into an HTML response. """ # called in host app response_html = response.body toolbar_url = debug_toolbar_url(request, request.id) button_style = get_setting(request.registry.settings, 'button_style', '') css_path = request.static_url(STATIC_PATH + 'css/toolbar_button.css') toolbar_html = toolbar_html_template % { 'button_style': button_style, 'css_path': css_path, 'toolbar_url': toolbar_url} toolbar_html = toolbar_html.encode(response.charset or 'utf-8') response.body = replace_insensitive( response_html, bytes_('</body>'), toolbar_html + bytes_('</body>') )
def validate(self): stmt = self.request.params['sql'] params = self.request.params['params'] # Validate hash need = self.request.exc_history.token + stmt + url_quote(params) hash = hashlib.sha1(bytes_(need)).hexdigest() if hash != self.request.params['hash']: raise HTTPBadRequest('Bad token in request') return stmt, params
def validate(self): stmt = self.request.params['sql'] params = self.request.params['params'] # Validate hash need = self.token + stmt + url_quote(params) hash = hashlib.sha1(bytes_(need)).hexdigest() if hash != self.request.params['hash']: raise HTTPBadRequest('Bad token in request') return stmt, params
def validate(self): stmt = self.request.params["sql"] params = self.request.params["params"] # Validate hash need = self.request.exc_history.token + stmt + url_quote(params) hash = hashlib.sha1(bytes_(need)).hexdigest() if hash != self.request.params["hash"]: raise HTTPBadRequest("Bad token in request") return stmt, params
def test_inject_html(self): from pyramid_debugtoolbar.utils import STATIC_PATH self.config.add_static_view('_debugtoolbar/static', STATIC_PATH) self.config.add_route('debugtoolbar', '/_debugtoolbar/*subpath') response = Response('<body></body>') response.content_type = 'text/html' request = Request.blank('/') request.pdtb_id = 'abc' request.registry = self.config.registry toolbar = self._makeOne(request, [DummyPanel], [DummyPanel], []) toolbar.inject(request, response) self.assertTrue(bytes_('div id="pDebug"') in response.app_iter[0]) self.assertEqual(response.content_length, len(response.app_iter[0]))
def test_process_response_html(self): from pyramid_debugtoolbar.utils import ROOT_ROUTE_NAME from pyramid_debugtoolbar.utils import STATIC_PATH self.config.add_static_view('_debugtoolbar/static', STATIC_PATH) self.config.add_route(ROOT_ROUTE_NAME, '/_debugtoolbar') response = Response('<body></body>') response.content_type = 'text/html' request = Request.blank('/') request.registry = self.config.registry toolbar = self._makeOne(request, [DummyPanel]) toolbar.process_response(response) self.assertTrue(response.processed) self.assertTrue(bytes_('div id="pDebug"') in response.app_iter[0])
def test_passing_of_button_style(self): from pyramid_debugtoolbar.utils import STATIC_PATH self.config.add_static_view('_debugtoolbar/static', STATIC_PATH) self.config.add_route('debugtoolbar', '/_debugtoolbar/*subpath') self.config.registry.settings['debugtoolbar.button_style'] = \ 'top:120px;zoom:50%' response = Response('<body></body>') response.content_type = 'text/html' request = Request.blank('/') request.pdtb_id = 'abc' request.registry = self.config.registry toolbar = self._makeOne(request, [DummyPanel], [DummyPanel], []) toolbar.inject(request, response) self.assertTrue(bytes_('top:120px;zoom:50%') in response.app_iter[0])
def inject(self, request, response): """ Inject the debug toolbar iframe into an HTML response. """ # called in host app response_html = response.body toolbar_url = debug_toolbar_url(request, request.id) button_style = get_setting(request.registry.settings, "button_style", "") css_path = request.static_url(STATIC_PATH + "css/toolbar.css") toolbar_html = toolbar_html_template % { "button_style": button_style, "css_path": css_path, "toolbar_url": toolbar_url, } toolbar_html = toolbar_html.encode(response.charset or "utf-8") response.body = replace_insensitive(response_html, bytes_("</body>"), toolbar_html + bytes_("</body>"))
def test_passing_of_button_style(self): from pyramid_debugtoolbar.utils import ROOT_ROUTE_NAME from pyramid_debugtoolbar.utils import STATIC_PATH self.config.include('pyramid_jinja2') self.config.add_static_view('_debugtoolbar/static', STATIC_PATH) self.config.add_route(ROOT_ROUTE_NAME, '/_debugtoolbar') self.config.registry.settings['debugtoolbar.button_style'] = \ 'top:120px;zoom:50%' response = Response('<body></body>') response.content_type = 'text/html' request = Request.blank('/') request.registry = self.config.registry toolbar = self._makeOne(request, [DummyPanel]) toolbar.process_response(response) self.assertTrue(response.processed) self.failUnless(bytes_('top:120px;zoom:50%') in response.app_iter[0])
def content(self): if not self.queries: return 'No queries in executed in request.' data = [] for query in self.queries: stmt = query['statement'] is_select = stmt.strip().lower().startswith('select') params = '' try: params = url_quote(json.dumps(query['parameters'])) except TypeError: pass # object not JSON serializable except UnicodeDecodeError: pass # parameters contain non-utf8 (probably binary) data need = self.request.exc_history.token + stmt + params hash = hashlib.sha1(bytes_(need)).hexdigest() data.append({ 'engine_id': query['engine_id'], 'duration': query['duration'], 'sql': format_sql(stmt), 'raw_sql': stmt, 'hash': hash, 'parameters': query['parameters'], 'params': params, 'is_select': is_select, 'context': query['context'], }) vars = { 'static_path': self.request.static_url(STATIC_PATH), 'root_path': self.request.route_url(ROOT_ROUTE_NAME), 'queries': data, 'text': text, } delattr(self.request, 'pdtb_sqla_queries') return self.render( 'pyramid_debugtoolbar.panels:templates/sqlalchemy.dbtmako', vars, self.request)
def content(self): if not self.queries: return 'No queries in executed in request.' data = [] for query in self.queries: stmt = query['statement'] is_select = stmt.strip().lower().startswith('select') params = '' try: params = url_quote(json.dumps(query['parameters'])) except TypeError: pass # object not JSON serializable except UnicodeDecodeError: pass # parameters contain non-utf8 (probably binary) data need = self.request.exc_history.token + stmt + params hash = hashlib.sha1(bytes_(need)).hexdigest() data.append({ 'engine_id': query['engine_id'], 'duration': query['duration'], 'sql': format_sql(stmt), 'raw_sql': stmt, 'hash': hash, 'parameters': query['parameters'], 'params': params, 'is_select': is_select, 'context': query['context'], }) vars = { 'static_path': self.request.static_url(STATIC_PATH), 'root_path': self.request.route_url(ROOT_ROUTE_NAME), 'queries':data, 'text':text, } delattr(self.request, 'pdtb_sqla_queries') return self.render( 'pyramid_debugtoolbar.panels:templates/sqlalchemy.dbtmako', vars, self.request)
def content(self): if not self.queries: return "No queries in executed in request." data = [] for query in self.queries: stmt = query["statement"] is_select = stmt.strip().lower().startswith("select") params = "" try: params = url_quote(json.dumps(query["parameters"])) except TypeError: pass # object not JSON serializable except UnicodeDecodeError: pass # parameters contain non-utf8 (probably binary) data need = self.request.exc_history.token + stmt + params hash = hashlib.sha1(bytes_(need)).hexdigest() data.append( { "engine_id": query["engine_id"], "duration": query["duration"], "sql": format_sql(stmt), "raw_sql": stmt, "hash": hash, "parameters": query["parameters"], "params": params, "is_select": is_select, "context": query["context"], } ) vars = { "static_path": self.request.static_url(STATIC_PATH), "root_path": self.request.route_url(ROOT_ROUTE_NAME), "queries": data, "text": text, } delattr(self.request, "pdtb_sqla_queries") return self.render("pyramid_debugtoolbar.panels:templates/sqlalchemy.dbtmako", vars, self.request)
def content(self): if not self.queries: return 'No queries in executed in request.' data = [] for query in self.queries: is_select = query['statement'].strip().lower().startswith('select') params = '' try: params = json.dumps(query['parameters']) except TypeError: pass # object not JSON serializable hash = hashlib.sha1( bytes_(self.request.exc_history.token + query['statement'] + params)).hexdigest() data.append({ 'engine_id': query['engine_id'], 'duration': query['duration'], 'sql': format_sql(query['statement']), 'raw_sql': query['statement'], 'hash': hash, 'params': params, 'is_select': is_select, 'context': query['context'], }) vars = { 'static_path': self.request.static_url(STATIC_PATH), 'root_path': self.request.route_url(ROOT_ROUTE_NAME), 'queries':data, } delattr(self.request, 'pdtb_sqla_queries') return self.render( 'pyramid_debugtoolbar.panels:templates/sqlalchemy.jinja2', vars, self.request)
def content(self): if not self.queries: return 'No queries in executed in request.' data = [] for query in self.queries: is_select = query['statement'].strip().lower().startswith('select') params = '' try: params = json.dumps(query['parameters']) except TypeError: pass # object not JSON serializable hash = hashlib.sha1( bytes_(self.request.exc_history.token + query['statement'] + params)).hexdigest() data.append({ 'engine_id': query['engine_id'], 'duration': query['duration'], 'sql': format_sql(query['statement']), 'raw_sql': query['statement'], 'hash': hash, 'params': params, 'is_select': is_select, 'context': query['context'], }) vars = { 'static_path': self.request.static_url(STATIC_PATH), 'root_path': self.request.route_url(ROOT_ROUTE_NAME), 'queries': data, } delattr(self.request, 'pdtb_sqla_queries') return self.render( 'pyramid_debugtoolbar.panels:templates/sqlalchemy.jinja2', vars, self.request)
def test_debug_repr(self): assert debug_repr([]) == "[]" assert debug_repr([1, 2]) == '[<span class="number">1</span>, <span class="number">2</span>]' assert debug_repr([1, "test"]) == '[<span class="number">1</span>, <span class="string">\'test\'</span>]' assert debug_repr([None]) == '[<span class="object">None</span>]' assert debug_repr(list(range(20))) == ( '[<span class="number">0</span>, <span class="number">1</span>, ' '<span class="number">2</span>, <span class="number">3</span>, ' '<span class="number">4</span>, <span class="number">5</span>, ' '<span class="number">6</span>, <span class="number">7</span>, ' '<span class="number">8</span>, <span class="number">9</span>, ' '<span class="number">10</span>, <span class="number">11</span>, ' '<span class="number">12</span>, <span class="number">13</span>, ' '<span class="number">14</span>, <span class="number">15</span>, ' '<span class="number">16</span>, <span class="number">17</span>, ' '<span class="number">18</span>, <span class="number">19</span>]' ) assert debug_repr({}) == "{}" assert ( debug_repr({"foo": 42}) == '{<span class="pair"><span class="key"><span class="string">\'foo\'' '</span></span>: <span class="value"><span class="number">42' "</span></span></span>}" ) result = debug_repr((1, bytes_("zwei"), text_("drei"))) if PY3: # pragma: no cover expected = ( '(<span class="number">1</span>, <span class="string">b\'' "zwei'</span>, <span class=\"string\">'drei'</span>)" ) else: expected = ( '(<span class="number">1</span>, <span class="string">\'' "zwei'</span>, <span class=\"string\">u'drei'</span>)" ) assert result == expected class Foo(object): def __repr__(self): return "<Foo 42>" assert debug_repr(Foo()) == '<span class="object"><Foo 42></span>' class MyList(list): pass tmp = debug_repr(MyList([1, 2])) assert ( tmp == '<span class="module">pyramid_debugtoolbar.tests.test_debug.</span>MyList([' '<span class="number">1</span>, <span class="number">2</span>])' ) result = debug_repr(re.compile(r"foo\d")) assert result == "re.compile(<span class=\"string regex\">r'foo\\d'</span>)" result = debug_repr(re.compile(text_(r"foo\d"))) if PY3: # pragma: no cover assert result == "re.compile(<span class=\"string regex\">r'foo\\d'</span>)" else: assert result == "re.compile(<span class=\"string regex\">ur'foo\\d'</span>)" assert debug_repr(frozenset("x")) == "frozenset([<span class=\"string\">'x'</span>])" assert debug_repr(set("x")) == "set([<span class=\"string\">'x'</span>])" a = [1] a.append(a) assert debug_repr(a) == '[<span class="number">1</span>, [...]]' class Foo(object): def __repr__(self): 1 / 0 result = debug_repr(Foo()) assert "division" in result
def test_it(self): result = self._callFUT("SELECT * FROM TBL") self.assertTrue(result.startswith(bytes_("<div")))
def test_debug_repr(self): assert debug_repr([]) == '[]' assert (debug_repr([ 1, 2 ]) == '[<span class="number">1</span>, <span class="number">2</span>]') assert debug_repr([1, 'test' ]) == ('[<span class="number">1</span>, ' '<span class="string">\'test\'</span>]') assert debug_repr([None]) == '[<span class="object">None</span>]' assert debug_repr(list(range(20))) == ( '[<span class="number">0</span>, <span class="number">1</span>, ' '<span class="number">2</span>, <span class="number">3</span>, ' '<span class="number">4</span>, <span class="number">5</span>, ' '<span class="number">6</span>, <span class="number">7</span>, ' '<span class="number">8</span>, <span class="number">9</span>, ' '<span class="number">10</span>, <span class="number">11</span>, ' '<span class="number">12</span>, <span class="number">13</span>, ' '<span class="number">14</span>, <span class="number">15</span>, ' '<span class="number">16</span>, <span class="number">17</span>, ' '<span class="number">18</span>, <span class="number">19</span>]') assert debug_repr({}) == '{}' assert debug_repr({'foo': 42}) == ( '{<span class="pair"><span class="key"><span class="string">\'foo\'' '</span></span>: <span class="value"><span class="number">42' '</span></span></span>}') result = debug_repr((1, bytes_('zwei'), text_('drei'))) if PY3: # pragma: no cover expected = ( '(<span class="number">1</span>, <span class="string">b\'' 'zwei\'</span>, <span class="string">\'drei\'</span>)') else: expected = ( '(<span class="number">1</span>, <span class="string">\'' 'zwei\'</span>, <span class="string">u\'drei\'</span>)') assert result == expected class Foo(object): def __repr__(self): return '<Foo 42>' assert (debug_repr( Foo()) == '<span class="object"><Foo 42></span>') class MyList(list): pass tmp = debug_repr(MyList([1, 2])) assert ( tmp == '<span class="module">tests.test_debug.</span>MyList([' '<span class="number">1</span>, <span class="number">2</span>])') result = debug_repr(re.compile(r'foo\d')) assert (result == 're.compile(<span class="string regex">r\'foo\\d\'</span>)') result = debug_repr(re.compile(text_(r'foo\d'))) if PY3: # pragma: no cover assert ( result == 're.compile(<span class="string regex">r\'foo\\d\'</span>)') else: assert ( result == 're.compile(<span class="string regex">ur\'foo\\d\'</span>)') assert (debug_repr( frozenset('x')) == 'frozenset([<span class="string">\'x\'</span>])' ) assert (debug_repr( set('x')) == 'set([<span class="string">\'x\'</span>])') a = [1] a.append(a) assert debug_repr(a) == '[<span class="number">1</span>, [...]]' class Foo(object): def __repr__(self): 1 / 0 result = debug_repr(Foo()) assert 'division' in result
def hexlify(value): """Hexlify int, str then returns native str type.""" # If integer str_ = str(value) hexified = text_(binascii.hexlify(bytes_(str_))) return hexified
def test_debug_repr(self): assert debug_repr([]) == '[]' assert debug_repr([1, 2]) == \ '[<span class="number">1</span>, <span class="number">2</span>]' assert debug_repr([1, 'test']) == \ '[<span class="number">1</span>, <span class="string">\'test\'</span>]' assert debug_repr([None]) == \ '[<span class="object">None</span>]' assert debug_repr(list(range(20))) == ( '[<span class="number">0</span>, <span class="number">1</span>, ' '<span class="number">2</span>, <span class="number">3</span>, ' '<span class="number">4</span>, <span class="number">5</span>, ' '<span class="number">6</span>, <span class="number">7</span>, ' '<span class="number">8</span>, <span class="number">9</span>, ' '<span class="number">10</span>, <span class="number">11</span>, ' '<span class="number">12</span>, <span class="number">13</span>, ' '<span class="number">14</span>, <span class="number">15</span>, ' '<span class="number">16</span>, <span class="number">17</span>, ' '<span class="number">18</span>, <span class="number">19</span>]' ) assert debug_repr({}) == '{}' assert debug_repr({'foo': 42}) == \ '{<span class="pair"><span class="key"><span class="string">\'foo\''\ '</span></span>: <span class="value"><span class="number">42' \ '</span></span></span>}' result = debug_repr((1, bytes_('zwei'), text_('drei'))) if PY3: # pragma: no cover expected = ( '(<span class="number">1</span>, <span class="string">b\'' 'zwei\'</span>, <span class="string">\'drei\'</span>)') else: expected = ( '(<span class="number">1</span>, <span class="string">\'' 'zwei\'</span>, <span class="string">u\'drei\'</span>)') assert result == expected class Foo(object): def __repr__(self): return '<Foo 42>' assert debug_repr(Foo()) == '<span class="object"><Foo 42></span>' class MyList(list): pass tmp = debug_repr(MyList([1, 2])) assert tmp == \ '<span class="module">pyramid_debugtoolbar.tests.test_debug.</span>MyList([' \ '<span class="number">1</span>, <span class="number">2</span>])' result = debug_repr(re.compile(r'foo\d')) assert result == \ 're.compile(<span class="string regex">r\'foo\\d\'</span>)' result = debug_repr(re.compile(text_(r'foo\d'))) if PY3: # pragma: no cover assert result == \ 're.compile(<span class="string regex">r\'foo\\d\'</span>)' else: assert result == \ 're.compile(<span class="string regex">ur\'foo\\d\'</span>)' assert debug_repr(frozenset('x')) == \ 'frozenset([<span class="string">\'x\'</span>])' assert debug_repr(set('x')) == \ 'set([<span class="string">\'x\'</span>])' a = [1] a.append(a) assert debug_repr(a) == '[<span class="number">1</span>, [...]]' class Foo(object): def __repr__(self): 1/0 result = debug_repr(Foo()) assert 'division' in result
def test_it(self): result = self._callFUT('SELECT * FROM TBL') self.assertTrue(result.startswith(bytes_('<div')))