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)
Example #3
0
 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)
Example #4
0
 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'})
Example #7
0
 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)
Example #9
0
 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"))
     )
Example #10
0
 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
         )
Example #11
0
 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)
Example #12
0
    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"))
Example #13
0
    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'))
Example #14
0
 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)
Example #15
0
 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"))
     )
Example #16
0
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))
Example #17
0
 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)
Example #18
0
 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, &lt;b&gt;fred&lt;/b&gt;!\n'))
     result = render('fixtures/nonminimal.mak',
                     {'name': '<b>fred</b>'}).replace('\r', '')
     self.assertEqual(result, text_('Hello, &lt;b&gt;fred&lt;/b&gt;!\n'))
Example #19
0
 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)
Example #21
0
    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'))
Example #22
0
    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'))
Example #23
0
 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})
Example #24
0
 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')
         )
Example #25
0
 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'], ())
Example #26
0
 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'))
          )
Example #27
0
    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)
Example #28
0
    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')
Example #29
0
    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
Example #30
0
    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
Example #31
0
 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)
Example #32
0
 def test_element_urllquoted(self):
     self.assertEqual(self._callFUT('/foo/space%20thing/bar'),
                      (text_('foo'), text_('space thing'), text_('bar')))
Example #33
0
 def test_path_startswith_endswith(self):
     self.assertEqual(self._callFUT('/foo/'), (text_('foo'), ))
Example #34
0
 def test_onedot(self):
     self.assertEqual(self._callFUT('foo/./bar'),
                      (text_('foo'), text_('bar')))
Example #35
0
 def test_twodots_at_start(self):
     self.assertEqual(self._callFUT('../../bar'), (text_('bar'), ))
Example #36
0
 def test_unicode_simple(self):
     path = text_('/abc')
     self.assertEqual(self._callFUT(path), (text_('abc'), ))
Example #37
0
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,
Example #38
0
 def render_unicode(self, **values):
     if self.exc:
         raise self.exc
     self.values = values
     return text_('result')
Example #39
0
 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, &lt;b&gt;fred&lt;/b&gt;!\n'))
Example #40
0
 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'))
Example #41
0
 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'))
Example #42
0
 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'))
Example #43
0
 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'))
Example #44
0
 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'))
Example #45
0
 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')))
Example #46
0
 def json_body(self):
     return json.loads(text_(self.body, self.charset))
Example #47
0
 def test_twodots(self):
     self.assertEqual(self._callFUT('foo/../bar'), (text_('bar'), ))
Example #48
0
 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'))
Example #49
0
 def test_empty_elements(self):
     self.assertEqual(self._callFUT('foo///'), (text_('foo'), ))
Example #50
0
 def new_csrf_token(self):
     token = text_(binascii.hexlify(os.urandom(20)))
     self['_csrft_'] = token
     return token
Example #51
0
 def test_unicode_undecodeable_to_ascii(self):
     path = text_(b'/La Pe\xc3\xb1a', 'utf-8')
     self.assertRaises(UnicodeEncodeError, self._callFUT, path)
Example #52
0
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))
Example #53
0
 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'), ))
Example #54
0
 def test_render_namespace(self):
     from pyramid.renderers import render
     result = render('hellocompo.mak', {}).replace('\r', '')
     self.assertEqual(result, text_('\nNamespace\nHello \nWorld!\n'))
Example #55
0
 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'], '')
Example #56
0
 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)
Example #57
0
 def test_highorder(self):
     la = b'La Pe\xc3\xb1a'
     latin1 = native_(la)
     result = self._callFUT(latin1)
     self.assertEqual(result, (text_(la, 'utf-8'), ))
Example #58
0
 def test_unicode(self):
     la = text_(b'/La Pe\xc3\xb1a', 'utf-8')
     result = self._callFUT(la)
     self.assertEqual(result, '%2FLa%20Pe%C3%B1a')
Example #59
0
 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'))
Example #60
0
 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'))