[devtools] qunit: stop using deprecated assert functions
equals -> equal
same -> deepEqual
Related to #5533333.
# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
#
# This file is part of CubicWeb.
#
# CubicWeb is free software: you can redistribute it and/or modify it under the
# terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 2.1 of the License, or (at your option)
# any later version.
#
# CubicWeb is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License along
# with CubicWeb. If not, see <http://www.gnu.org/licenses/>.
"""json export views"""
__docformat__ = "restructuredtext en"
_ = unicode
from cubicweb.uilib import rest_traceback
from cubicweb.utils import json_dumps
from cubicweb.predicates import ExpectedValuePredicate, any_rset, empty_rset
from cubicweb.view import EntityView, AnyRsetView
from cubicweb.web.application import anonymized_request
from cubicweb.web.views import basecontrollers, management
class JsonpController(basecontrollers.ViewController):
"""The jsonp controller is the same as a ViewController but :
- anonymize request (avoid CSRF attacks)
- if ``vid`` parameter is passed, make sure it's sensible (i.e. either
"jsonexport" or "ejsonexport")
- if ``callback`` request parameter is passed, it's used as json padding
Response's content-type will either be ``application/javascript`` or
``application/json`` depending on ``callback`` parameter presence or not.
"""
__regid__ = 'jsonp'
def publish(self, rset=None):
if 'vid' in self._cw.form:
vid = self._cw.form['vid']
if vid not in ('jsonexport', 'ejsonexport'):
self.warning("vid %s can't be used with jsonp controller, "
"falling back to jsonexport", vid)
self._cw.form['vid'] = 'jsonexport'
else: # if no vid is specified, use jsonexport
self._cw.form['vid'] = 'jsonexport'
if self._cw.vreg.config['anonymize-jsonp-queries']:
with anonymized_request(self._cw):
return self._get_json_data(rset)
else:
return self._get_json_data(rset)
def _get_json_data(self, rset):
json_data = super(JsonpController, self).publish(rset)
if 'callback' in self._cw.form: # jsonp
json_padding = self._cw.form['callback'].encode('ascii')
# use ``application/javascript`` if ``callback`` parameter is
# provided, keep ``application/json`` otherwise
self._cw.set_content_type('application/javascript')
json_data = b'%s(%s)' % (json_padding, json_data)
return json_data
class JsonMixIn(object):
"""mixin class for json views
Handles the following optional request parameters:
- ``_indent`` : must be an integer. If found, it is used to pretty print
json output
"""
templatable = False
content_type = 'application/json'
binary = True
def wdata(self, data):
if '_indent' in self._cw.form:
indent = int(self._cw.form['_indent'])
else:
indent = None
self.w(json_dumps(data, indent=indent))
class JsonRsetView(JsonMixIn, AnyRsetView):
"""dumps raw result set in JSON format"""
__regid__ = 'jsonexport'
__select__ = any_rset() # means rset might be empty or have any shape
title = _('json-export-view')
def call(self):
# XXX mimic w3c recommandations to serialize SPARQL results in json?
# http://www.w3.org/TR/rdf-sparql-json-res/
self.wdata(self.cw_rset.rows)
class JsonEntityView(JsonMixIn, EntityView):
"""dumps rset entities in JSON
The following additional metadata is added to each row :
- ``__cwetype__`` : entity type
"""
__regid__ = 'ejsonexport'
__select__ = EntityView.__select__ | empty_rset()
title = _('json-entities-export-view')
def call(self):
entities = []
for entity in self.cw_rset.entities():
entity.complete() # fetch all attributes
# hack to add extra metadata
entity.cw_attr_cache.update({
'__cwetype__': entity.cw_etype,
})
entities.append(entity)
self.wdata(entities)
class _requested_vid(ExpectedValuePredicate):
"""predicate that checks vid parameter value
It differs from ``match_view`` in that it doesn't expect a ``view``
parameter to be given to ``select`` but will rather check
``req.form['vid']`` to match expected vid.
"""
def __call__(self, cls, req, rset=None, **kwargs):
return req.form.get('vid') in self.expected
class JsonErrorView(JsonMixIn, management.ErrorView):
"""custom error view selected when client asks for a json view
The returned json object will contain err / traceback informations.
"""
__select__ = (management.ErrorView.__select__ &
_requested_vid('jsonexport', 'ejsonexport'))
def call(self):
errmsg, exclass, excinfo = self._excinfo()
self.wdata({
'errmsg': errmsg,
'exclass': exclass,
'traceback': rest_traceback(excinfo, errmsg),
})