def test_call_with_vh_root_highorder(self): bar = DummyContext(None, 'bar') foo = DummyContext(bar, text_(b'Qu\xc3\xa9bec', 'utf-8')) root = DummyContext(foo, 'root') policy = self._makeOne(root) if PY3: # pragma: no cover vhm_root = b'/Qu\xc3\xa9bec'.decode('latin-1') else: vhm_root = b'/Qu\xc3\xa9bec' environ = self._getEnviron(HTTP_X_VHM_ROOT=vhm_root, PATH_INFO='/bar') request = DummyRequest(environ) result = policy(request) self.assertEqual(result['context'], bar) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ()) self.assertEqual( result['traversed'], (text_(b'Qu\xc3\xa9bec', 'utf-8'), text_('bar')) ) self.assertEqual(result['root'], policy.root) self.assertEqual(result['virtual_root'], foo) self.assertEqual( result['virtual_root_path'], (text_(b'Qu\xc3\xa9bec', 'utf-8'),) )
def test_absolute_unicode_found(self): # test for bug wiggy found in wild, traceback stack: # root = u'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF' # wiggy's code: section=find_resource(page, root) # find_resource L76: D = traverse(resource, path) # traverse L291: return traverser(request) # __call__ line 568: vpath_tuple = traversal_path(vpath) # lru_cached line 91: f(*arg) # traversal_path line 443: path.encode('ascii') # UnicodeEncodeError: 'ascii' codec can't encode characters in # position 1-12: ordinal not in range(128) # # solution: encode string to ascii in pyramid.traversal.traverse # before passing it along to webob as path_info from pyramid.traversal import ResourceTreeTraverser unprintable = DummyContext() root = DummyContext(unprintable) unprintable.__parent__ = root unprintable.__name__ = text_( b'/\xe6\xb5\x81\xe8\xa1\x8c\xe8\xb6\x8b\xe5\x8a\xbf', 'utf-8') root.__parent__ = None root.__name__ = None traverser = ResourceTreeTraverser self._registerTraverser(traverser) result = self._callFUT( root, text_(b'/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF') ) self.assertEqual(result, unprintable)
def test_it(self): class Dummy: pass ob1 = Dummy() ob2 = Dummy() resources = {'/ob1':ob1, '/ob2':ob2} from pyramid import testing testing.registerResources(resources) from pyramid.interfaces import ITraverser adapter = self.registry.getAdapter(None, ITraverser) result = adapter(DummyRequest({'PATH_INFO':'/ob1'})) self.assertEqual(result['context'], ob1) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ()) self.assertEqual(result['traversed'], (text_('ob1'),)) self.assertEqual(result['virtual_root'], ob1) self.assertEqual(result['virtual_root_path'], ()) result = adapter(DummyRequest({'PATH_INFO':'/ob2'})) self.assertEqual(result['context'], ob2) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ()) self.assertEqual(result['traversed'], (text_('ob2'),)) self.assertEqual(result['virtual_root'], ob2) self.assertEqual(result['virtual_root_path'], ()) self.assertRaises(KeyError, adapter, DummyRequest({'PATH_INFO':'/ob3'})) from pyramid.traversal import find_resource self.assertEqual(find_resource(None, '/ob1'), ob1)
def test_testing_resources(self): from pyramid.traversal import find_resource from pyramid.interfaces import ITraverser ob1 = object() ob2 = object() resources = {'/ob1':ob1, '/ob2':ob2} config = self._makeOne(autocommit=True) config.testing_resources(resources) adapter = config.registry.getAdapter(None, ITraverser) result = adapter(DummyRequest({'PATH_INFO':'/ob1'})) self.assertEqual(result['context'], ob1) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ()) self.assertEqual(result['traversed'], (text_('ob1'),)) self.assertEqual(result['virtual_root'], ob1) self.assertEqual(result['virtual_root_path'], ()) result = adapter(DummyRequest({'PATH_INFO':'/ob2'})) self.assertEqual(result['context'], ob2) self.assertEqual(result['view_name'], '') self.assertEqual(result['subpath'], ()) self.assertEqual(result['traversed'], (text_('ob2'),)) self.assertEqual(result['virtual_root'], ob2) self.assertEqual(result['virtual_root_path'], ()) self.assertRaises(KeyError, adapter, DummyRequest({'PATH_INFO':'/ob3'})) try: config.begin() self.assertEqual(find_resource(None, '/ob1'), ob1) finally: config.end()
def test_docs_sample_generate(self): # sample from urldispatch.rst pattern = text_(b'/La Pe\xc3\xb1a/{city}', 'utf-8') _, generator = self._callFUT(pattern) self.assertEqual( generator({'city':text_(b'Qu\xc3\xa9bec', 'utf-8')}), '/La%20Pe%C3%B1a/Qu%C3%A9bec')
def test_matcher_functional_newstyle(self): self.matches('/{x}', '', None) self.matches('/{x}', '/', None) self.matches('/abc/{def}', '/abc/', None) self.matches('/{x}', '/a', {'x':'a'}) self.matches('zzz/{x}', '/zzz/abc', {'x':'abc'}) self.matches('zzz/{x}*traverse', '/zzz/abc', {'x':'abc', 'traverse':()}) self.matches('zzz/{x}*traverse', '/zzz/abc/def/g', {'x':'abc', 'traverse':('def', 'g')}) self.matches('*traverse', '/zzz/abc', {'traverse':('zzz', 'abc')}) self.matches('*traverse', '/zzz/ abc', {'traverse':('zzz', ' abc')}) #'/La%20Pe%C3%B1a' self.matches('{x}', text_(b'/La Pe\xc3\xb1a', 'utf-8'), {'x':text_(b'La Pe\xc3\xb1a', 'utf-8')}) # '/La%20Pe%C3%B1a/x' self.matches('*traverse', text_(b'/La Pe\xc3\xb1a/x'), {'traverse':(text_(b'La Pe\xc3\xb1a'), 'x')}) self.matches('/foo/{id}.html', '/foo/bar.html', {'id':'bar'}) self.matches('/{num:[0-9]+}/*traverse', '/555/abc/def', {'num':'555', 'traverse':('abc', 'def')}) self.matches('/{num:[0-9]*}/*traverse', '/555/abc/def', {'num':'555', 'traverse':('abc', 'def')}) self.matches('zzz/{_}', '/zzz/abc', {'_':'abc'}) self.matches('zzz/{_abc}', '/zzz/abc', {'_abc':'abc'}) self.matches('zzz/{abc_def}', '/zzz/abc', {'abc_def':'abc'})
def test_resource_url_anchor_is_encoded_utf8_if_unicode(self): request = self._makeOne() self._registerResourceURL(request.registry) context = DummyContext() uc = text_(b"La Pe\xc3\xb1a", "utf-8") result = request.resource_url(context, anchor=uc) self.assertEqual(result, native_(text_(b"http://example.com:5432/context/#La Pe\xc3\xb1a", "utf-8"), "utf-8"))
def test_generate_with_string_remainder_and_unicode_replacement(self): pattern = text_(b'/abc*remainder', 'utf-8') _, generator = self._callFUT(pattern) result = generator( {'remainder': text_(b'/Qu\xc3\xa9bec/La Pe\xc3\xb1a', 'utf-8')} ) self.assertEqual(result, '/abc/Qu%C3%A9bec/La%20Pe%C3%B1a') # should be a native string self.assertEqual(type(result), str)
def test___call__traverse_matches_with_highorder_chars(self): inst = self._makeOne(text_(b"/La Pe\xc3\xb1a/{x}", "utf-8")) info = {"match": {"x": text_(b"Qu\xc3\xa9bec", "utf-8")}} request = Dummy() result = inst(info, request) self.assertEqual(result, True) self.assertEqual( info["match"]["traverse"], (text_(b"La Pe\xc3\xb1a", "utf-8"), text_(b"Qu\xc3\xa9bec", "utf-8")) )
def response(self): return Response( body=self.gf.read(), content_disposition='attachment; filename={}'.format( text_(self.gf.filename, encoding='utf8')), content_type=text_(self.gf.content_type, encoding='utf8') if \ self.gf.content_type else 'binary/octet-stream', content_length=self.gf.length )
def test_subpath_path_info_and_script_name_have_utf8(self): encoded = native_(text_(b"La Pe\xc3\xb1a")) decoded = text_(bytes_(encoded), "utf-8") request = DummyRequest({"PATH_INFO": "/" + encoded, "SCRIPT_NAME": "/" + encoded}) request.subpath = (decoded,) response = self._callFUT(request, "app") self.assertTrue(request.copied) self.assertEqual(response, "app") self.assertEqual(request.environ["SCRIPT_NAME"], "/" + encoded) self.assertEqual(request.environ["PATH_INFO"], "/" + encoded)
def test_route_url_with_anchor_unicode(self): from pyramid.interfaces import IRoutesMapper request = self._makeOne() mapper = DummyRoutesMapper(route=DummyRoute("/1/2/3")) request.registry.registerUtility(mapper, IRoutesMapper) anchor = text_(b"La Pe\xc3\xb1a", "utf-8") result = request.route_url("flub", _anchor=anchor) self.assertEqual(result, native_(text_(b"http://example.com:5432/1/2/3#La Pe\xc3\xb1a", "utf-8"), "utf-8"))
def test_messages_error_msg(self): add_message(self.request, 'error', 'error') self.assertEqual( render_messages(self.request).strip(), text_('<div class="alert alert-error alert-danger">\n <a class="close" data-dismiss="alert">×</a>\n error\n</div>','utf-8')) add_message(self.request, ValueError('Error'), 'error') self.assertEqual( render_messages(self.request).strip(), text_('<div class="alert alert-error alert-danger">\n <a class="close" data-dismiss="alert">×</a>\n ValueError: Error\n</div>','utf-8'))
def test_subpath_path_info_and_script_name_have_utf8(self): encoded = native_(text_(b'La Pe\xc3\xb1a')) decoded = text_(bytes_(encoded), 'utf-8') request = DummyRequest({'PATH_INFO':'/' + encoded, 'SCRIPT_NAME':'/' + encoded}) request.subpath = (decoded, ) response = self._callFUT(request, 'app') self.assertTrue(request.copied) self.assertEqual(response, 'app') self.assertEqual(request.environ['SCRIPT_NAME'], '/' + encoded) self.assertEqual(request.environ['PATH_INFO'], '/' + encoded)
def test_traverse_matches_with_highorder_chars(self): order, predicates, phash = self._callFUT(traverse=text_(b"/La Pe\xc3\xb1a/{x}", "utf-8")) self.assertEqual(len(predicates), 1) pred = predicates[0] info = {"match": {"x": text_(b"Qu\xc3\xa9bec", "utf-8")}} request = DummyRequest() result = pred(info, request) self.assertEqual(result, True) self.assertEqual( info["match"]["traverse"], (text_(b"La Pe\xc3\xb1a", "utf-8"), text_(b"Qu\xc3\xa9bec", "utf-8")) )
def object_description(object): """ Produce a human-consumable text description of ``object``, usually involving a Python dotted name. For example: >>> object_description(None) u'None' >>> from xml.dom import minidom >>> object_description(minidom) u'module xml.dom.minidom' >>> object_description(minidom.Attr) u'class xml.dom.minidom.Attr' >>> object_description(minidom.Attr.appendChild) u'method appendChild of class xml.dom.minidom.Attr' If this method cannot identify the type of the object, a generic description ala ``object <object.__name__>`` will be returned. If the object passed is already a string, it is simply returned. If it is a boolean, an integer, a list, a tuple, a set, or ``None``, a (possibly shortened) string representation is returned. """ if isinstance(object, string_types): return text_(object) if isinstance(object, integer_types): return text_(str(object)) if isinstance(object, (bool, float, type(None))): return text_(str(object)) if isinstance(object, set): if PY3: # pragma: no cover return shortrepr(object, '}') else: return shortrepr(object, ')') if isinstance(object, tuple): return shortrepr(object, ')') if isinstance(object, list): return shortrepr(object, ']') if isinstance(object, dict): return shortrepr(object, '}') module = inspect.getmodule(object) if module is None: return text_('object %s' % str(object)) modulename = module.__name__ if inspect.ismodule(object): return text_('module %s' % modulename) if inspect.ismethod(object): oself = getattr(object, '__self__', None) if oself is None: # pragma: no cover oself = getattr(object, 'im_self', None) return text_('method %s of class %s.%s' % (object.__name__, modulename, oself.__class__.__name__)) if inspect.isclass(object): dottedname = '%s.%s' % (modulename, object.__name__) return text_('class %s' % dottedname) if inspect.isfunction(object): dottedname = '%s.%s' % (modulename, object.__name__) return text_('function %s' % dottedname) return text_('object %s' % str(object))
def pre(self, command, output_dir, vars): vars['random_string'] = native_(binascii.hexlify(os.urandom(20))) # placeholder text values vars['one'] = text_('one') vars['two'] = text_('two') package_logger = vars['package'] if package_logger == 'root': # Rename the app logger in the rare case a project is named 'root' package_logger = 'app' vars['package_logger'] = package_logger return Template.pre(self, command, output_dir, vars)
def test_add_mako_renderer(self): from pyramid.renderers import render self.config.add_settings({'foo.directories': 'pyramid_mako.tests:fixtures'}) self.config.add_mako_renderer('.foo', settings_prefix='foo.') result = render('nonminimal.foo', {'name': '<b>fred</b>'}).replace('\r', '') self.assertEqual(result, text_('Hello, <b>fred</b>!\n')) result = render('fixtures/nonminimal.mak', {'name': '<b>fred</b>'}).replace('\r', '') self.assertEqual(result, text_('Hello, <b>fred</b>!\n'))
def test___call__traverse_matches_with_highorder_chars(self): inst = self._makeOne(text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8')) info = {'match':{'x':text_(b'Qu\xc3\xa9bec', 'utf-8')}} request = Dummy() result = inst(info, request) self.assertEqual(result, True) self.assertEqual( info['match']['traverse'], (text_(b'La Pe\xc3\xb1a', 'utf-8'), text_(b'Qu\xc3\xa9bec', 'utf-8')) )
def test_add_route_with_path_info_regex(self): config = self._makeOne(autocommit=True) config.add_route('name', 'path', path_info=text_(br'/La Pe\w*', 'utf-8')) route = self._assertRoute(config, 'name', 'path', 1) predicate = route.predicates[0] request = self._makeRequest(config) request.upath_info = text_(b'/La Pe\xc3\xb1a', 'utf-8') self.assertEqual(predicate(None, request), True) request = self._makeRequest(config) request.upath_info = text_('/') self.assertEqual(predicate(None, request), False)
def test_messages_error_msg(self): from ptah import view self.init_ptah() view.add_message(self.request, 'error', 'error') self.assertEqual( view.render_messages(self.request), text_('<div class="alert alert-error">\n <a class="close" data-dismiss="alert">×</a>\n error\n</div>\n','utf-8')) view.add_message(self.request, ValueError('Error'), 'error') self.assertEqual( view.render_messages(self.request), text_('<div class="alert alert-error">\n <a class="close" data-dismiss="alert">×</a>\n ValueError: Error\n</div>\n','utf-8'))
def test_messages_error_msg(self): from ptah import view self.init_ptah() view.add_message(self.request, 'error', 'error') self.assertEqual( view.render_messages(self.request), text_('<div class="alert-message error">\n <a class="close" href="#">×</a>\n <p>error</p>\n</div>\n','utf-8')) view.add_message(self.request, ValueError('Error'), 'error') self.assertEqual( view.render_messages(self.request), text_('<div class="alert-message error">\n <a class="close" href="#">×</a>\n <p>ValueError: Error</p>\n</div>\n','utf-8'))
def test_call_with_defname_with_tuple_value_twice(self): lookup = DummyLookup() instance1 = self._makeOne('path', 'defname', lookup) result1 = instance1(('defname1', {}), {'context':1}) self.assertEqual(lookup.deffed, 'defname1') self.assertEqual(result1, text_('result')) self.assertEqual(lookup.values, {'_context':1}) instance2 = self._makeOne('path', 'defname', lookup) result2 = instance2(('defname2', {}), {'context':2}) self.assertNotEqual(lookup.deffed, 'defname1') self.assertEqual(lookup.deffed, 'defname2') self.assertEqual(result2, text_('result')) self.assertEqual(lookup.values, {'_context':2})
def test_resource_url_anchor_is_encoded_utf8_if_unicode(self): request = self._makeOne() self._registerContextURL(request.registry) context = DummyContext() uc = text_(b'La Pe\xc3\xb1a', 'utf-8') result = request.resource_url(context, anchor=uc) self.assertEqual( result, native_( text_(b'http://example.com/context/#La Pe\xc3\xb1a', 'utf-8'), 'utf-8') )
def test_call_withconn_getitem_withpath_withsubpath(self): foo = DummyContext() root = DummyContext(foo) policy = self._makeOne(root) environ = self._getEnviron() request = DummyRequest(environ, path_info=text_('/foo/bar/baz/buz')) result = policy(request) self.assertEqual(result['context'], foo) self.assertEqual(result['view_name'], 'bar') self.assertEqual(result['subpath'], ('baz', 'buz')) self.assertEqual(result['traversed'], (text_('foo'),)) self.assertEqual(result['root'], root) self.assertEqual(result['virtual_root'], root) self.assertEqual(result['virtual_root_path'], ())
def test_traverse_matches_with_highorder_chars(self): order, predicates, phash = self._callFUT( traverse=text_(b'/La Pe\xc3\xb1a/{x}', 'utf-8')) self.assertEqual(len(predicates), 1) pred = predicates[0] info = {'match':{'x':text_(b'Qu\xc3\xa9bec', 'utf-8')}} request = DummyRequest() result = pred(info, request) self.assertEqual(result, True) self.assertEqual( info['match']['traverse'], (text_(b'La Pe\xc3\xb1a', 'utf-8'), text_(b'Qu\xc3\xa9bec', 'utf-8')) )
def test_forbidden_user(self): from ptahcrowd.forbidden import Forbidden class Context(object): """ """ __name__ = 'test' request = self.request request.root = Context() ptah.auth_service.set_userid('user') class Principal(object): pass def get_principal(): return Principal() orig = ptah.auth_service.get_current_principal ptah.auth_service.get_current_principal = get_principal res = render_view_to_response(HTTPForbidden(), request) ptah.auth_service.get_current_principal = orig self.assertEqual(text_(res.status), '403 Forbidden') self.assertIn( '<h1>Your are not allowed to access this part of site.</h1>', res.text)
def test_forbidden(self): from ptahcrowd.forbidden import Forbidden class Context(object): """ """ request = DummyRequest() request.url = 'http://example.com' request.application_url = 'http://example.com' request.root = Context() excview = Forbidden(HTTPForbidden(), request) excview.update() res = request.response self.assertIs(excview.__parent__, request.root) self.assertEqual(res.status, '302 Found') self.assertEqual( text_(res.headers['location']), 'http://example.com/login.html?came_from=http%3A%2F%2Fexample.com') excview = Forbidden(HTTPForbidden(), request) res = excview() self.assertEqual(res.status, '302 Found')
def view_info(self, discr, context, request, content): introspector = request.registry.introspector template = 'unknown' intr = introspector.get('templates', discr) if intr is not None: # pragma: no cover template = intr['name'] intr = introspector.get('views', discr) if intr is None: # pragma: no cover return content view = intr['callable'] data = OrderedDict( (('name', intr['name']), ('route-name', intr['route_name']), ('view-factory', '%s.%s'%(view.__module__, view.__name__)), ('python-module', inspect.getmodule(view).__name__), ('python-module-location', inspect.getsourcefile(view)), ('python-module-line', inspect.getsourcelines(view)[-1]), ('renderer', template), ('context', '%s.%s'%(context.__class__.__module__, context.__class__.__name__)), ('context-path', request.resource_url(context)), )) content = text_('\n<!-- view:\n%s \n-->\n'\ '<div style="border: 2px solid red">%s</div>')%( json.dumps(data, indent=2), content) return content
def __call__(self, context, request): chain = query_layout_chain(request.root, context, request, self.layout) if not chain: log.warning("Can't find layout '%s' for context '%s'", self.layout, context) if isinstance(request.wrapped_response, HTTPException): return request.wrapped_response debug = getattr(request, '__layout_debug__', False) content = text_(request.wrapped_body, 'utf-8') if debug: content = self.view_info(debug, context, request, content) for layout, layoutcontext in chain: value = layout.view(layoutcontext, request) if value is None: value = {} system = {'view': request.__view__, 'renderer_info': layout.renderer, 'context': layoutcontext, 'request': request, 'wrapped_content': content} content = layout.renderer.render(value, system, request) if debug: content = self.layout_info( layout, layoutcontext, request, content) request.response.text = content return request.response
def test_utf16(self): from pyramid.exceptions import URLDecodeError la = text_(b'La Pe\xc3\xb1a', 'utf-8').encode('utf-16') encoded = url_quote(la) path = '/'.join([encoded, encoded]) self.assertRaises(URLDecodeError, self._callFUT, path)
def test_element_urllquoted(self): self.assertEqual(self._callFUT('/foo/space%20thing/bar'), (text_('foo'), text_('space thing'), text_('bar')))
def test_path_startswith_endswith(self): self.assertEqual(self._callFUT('/foo/'), (text_('foo'), ))
def test_onedot(self): self.assertEqual(self._callFUT('foo/./bar'), (text_('foo'), text_('bar')))
def test_twodots_at_start(self): self.assertEqual(self._callFUT('../../bar'), (text_('bar'), ))
def test_unicode_simple(self): path = text_('/abc') self.assertEqual(self._callFUT(path), (text_('abc'), ))
from pyramid.config.security import SecurityConfiguratorMixin from pyramid.config.settings import SettingsConfiguratorMixin from pyramid.config.testing import TestingConfiguratorMixin from pyramid.config.tweens import TweensConfiguratorMixin from pyramid.config.util import PredicateList, not_ from pyramid.config.views import ViewsConfiguratorMixin from pyramid.config.zca import ZCAConfiguratorMixin from pyramid.path import DottedNameResolver from pyramid.util import ( action_method, ActionInfo, ) empty = text_('') _marker = object() ConfigurationError = ConfigurationError # pyflakes not_ = not_ # pyflakes, this is an API class Configurator( TestingConfiguratorMixin, TweensConfiguratorMixin, SecurityConfiguratorMixin, ViewsConfiguratorMixin, RoutesConfiguratorMixin, ZCAConfiguratorMixin, I18NConfiguratorMixin,
def render_unicode(self, **values): if self.exc: raise self.exc self.values = values return text_('result')
def test_template_default_escaping(self): from pyramid.renderers import render result = render('nonminimal.mak', { 'name': '<b>fred</b>' }).replace('\r', '') self.assertEqual(result, text_('Hello, <b>fred</b>!\n'))
def test_get_renderer(self): from pyramid.renderers import get_renderer result = get_renderer('helloworld.mak') self.assertEqual( result.implementation().render_unicode().replace('\r', ''), text_('\nHello föö\n', 'utf-8'))
def test_implementation(self): lookup = DummyLookup() instance = self._makeOne('path', lookup) result = instance.implementation().render_unicode() self.assertTrue(isinstance(result, text_type)) self.assertEqual(result, text_('result'))
def test_render_to_response_pkg_spec(self): from pyramid.renderers import render_to_response result = render_to_response('pyramid.tests:fixtures/helloworld.mak', {'a': 1}) self.assertEqual(result.ubody.replace('\r', ''), text_('\nHello föö\n', 'utf-8'))
def test_render_inheritance_pkg_spec(self): from pyramid.renderers import render result = render('hello_inherit_pkg.mak', {}).replace('\r', '') self.assertEqual(result, text_('Layout\nHello World!\n'))
def test_params_decoded_from_utf_8_by_default(self): environ = {'PATH_INFO': '/', 'QUERY_STRING': 'la=La%20Pe%C3%B1a'} request = self._makeOne(environ) request.charset = None self.assertEqual(request.GET['la'], text_(b'La Pe\xf1a'))
def test_same_value_returned_if_cached(self): result1 = self._callFUT('/foo/bar') result2 = self._callFUT('/foo/bar') self.assertEqual(result1, (text_('foo'), text_('bar'))) self.assertEqual(result2, (text_('foo'), text_('bar')))
def json_body(self): return json.loads(text_(self.body, self.charset))
def test_twodots(self): self.assertEqual(self._callFUT('foo/../bar'), (text_('bar'), ))
def test_call(self): lookup = DummyLookup() instance = self._makeOne('path', lookup) result = instance({}, {'system': 1}) self.assertTrue(isinstance(result, text_type)) self.assertEqual(result, text_('result'))
def test_empty_elements(self): self.assertEqual(self._callFUT('foo///'), (text_('foo'), ))
def new_csrf_token(self): token = text_(binascii.hexlify(os.urandom(20))) self['_csrft_'] = token return token
def test_unicode_undecodeable_to_ascii(self): path = text_(b'/La Pe\xc3\xb1a', 'utf-8') self.assertRaises(UnicodeEncodeError, self._callFUT, path)
def object_description(object): """ Produce a human-consumable text description of ``object``, usually involving a Python dotted name. For example: .. code-block:: python >>> object_description(None) u'None' >>> from xml.dom import minidom >>> object_description(minidom) u'module xml.dom.minidom' >>> object_description(minidom.Attr) u'class xml.dom.minidom.Attr' >>> object_description(minidom.Attr.appendChild) u'method appendChild of class xml.dom.minidom.Attr' >>> If this method cannot identify the type of the object, a generic description ala ``object <object.__name__>`` will be returned. If the object passed is already a string, it is simply returned. If it is a boolean, an integer, a list, a tuple, a set, or ``None``, a (possibly shortened) string representation is returned. """ if isinstance(object, string_types): return text_(object) if isinstance(object, integer_types): return text_(str(object)) if isinstance(object, (bool, float, type(None))): return text_(str(object)) if isinstance(object, set): if PY3: # pragma: no cover return shortrepr(object, '}') else: return shortrepr(object, ')') if isinstance(object, tuple): return shortrepr(object, ')') if isinstance(object, list): return shortrepr(object, ']') if isinstance(object, dict): return shortrepr(object, '}') module = inspect.getmodule(object) if module is None: return text_('object %s' % str(object)) modulename = module.__name__ if inspect.ismodule(object): return text_('module %s' % modulename) if inspect.ismethod(object): oself = getattr(object, '__self__', None) if oself is None: # pragma: no cover oself = getattr(object, 'im_self', None) return text_('method %s of class %s.%s' % (object.__name__, modulename, oself.__class__.__name__)) if inspect.isclass(object): dottedname = '%s.%s' % (modulename, object.__name__) return text_('class %s' % dottedname) if inspect.isfunction(object): dottedname = '%s.%s' % (modulename, object.__name__) return text_('function %s' % dottedname) return text_('object %s' % str(object))
def test_unicode_highorder_chars(self): path = text_('/%E6%B5%81%E8%A1%8C%E8%B6%8B%E5%8A%BF') self.assertEqual( self._callFUT(path), (text_('\u6d41\u884c\u8d8b\u52bf', 'unicode_escape'), ))
def test_render_namespace(self): from pyramid.renderers import render result = render('hellocompo.mak', {}).replace('\r', '') self.assertEqual(result, text_('\nNamespace\nHello \nWorld!\n'))
def test_self_unicode_found(self): resource = DummyContext() traverser = make_traverser({'context': resource, 'view_name': ''}) self._registerTraverser(traverser) self._callFUT(resource, text_('')) self.assertEqual(resource.request.environ['PATH_INFO'], '')
def test_highorder_undecodeable(self): from pyramid.exceptions import URLDecodeError la = text_(b'La Pe\xc3\xb1a', 'utf-8') notlatin1 = native_(la) self.assertRaises(URLDecodeError, self._callFUT, notlatin1)
def test_highorder(self): la = b'La Pe\xc3\xb1a' latin1 = native_(la) result = self._callFUT(latin1) self.assertEqual(result, (text_(la, 'utf-8'), ))
def test_unicode(self): la = text_(b'/La Pe\xc3\xb1a', 'utf-8') result = self._callFUT(la) self.assertEqual(result, '%2FLa%20Pe%C3%B1a')
def test_render_with_abs_path(self): from pyramid.renderers import render result = render('/helloworld.mak', {'a': 1}).replace('\r', '') self.assertEqual(result, text_('\nHello föö\n', 'utf-8'))
def test_render_from_fs(self): from pyramid.renderers import render self.config.add_settings({'reload_templates': True}) result = render('helloworld.mak', {'a': 1}).replace('\r', '') self.assertEqual(result, text_('\nHello föö\n', 'utf-8'))