| | |
| | | |
| | | from pyramid import testing |
| | | |
| | | from pyramid.compat import ( |
| | | text_, |
| | | WIN, |
| | | ) |
| | | from pyramid.compat import text_, WIN |
| | | |
| | | |
| | | class TestURLMethodsMixin(unittest.TestCase): |
| | | def setUp(self): |
| | |
| | | |
| | | def tearDown(self): |
| | | testing.tearDown() |
| | | |
| | | |
| | | def _makeOne(self, environ=None): |
| | | from pyramid.url import URLMethodsMixin |
| | | |
| | | if environ is None: |
| | | environ = {} |
| | | |
| | | class Request(URLMethodsMixin): |
| | | application_url = 'http://example.com:5432' |
| | | script_name = '' |
| | | |
| | | def __init__(self, environ): |
| | | self.environ = environ |
| | | |
| | | request = Request(environ) |
| | | request.registry = self.config.registry |
| | | return request |
| | |
| | | def _registerResourceURL(self, reg): |
| | | from pyramid.interfaces import IResourceURL |
| | | from zope.interface import Interface |
| | | |
| | | class DummyResourceURL(object): |
| | | physical_path = '/context/' |
| | | virtual_path = '/context/' |
| | | def __init__(self, context, request): pass |
| | | reg.registerAdapter(DummyResourceURL, (Interface, Interface), |
| | | IResourceURL) |
| | | |
| | | def __init__(self, context, request): |
| | | pass |
| | | |
| | | reg.registerAdapter( |
| | | DummyResourceURL, (Interface, Interface), IResourceURL |
| | | ) |
| | | return DummyResourceURL |
| | | |
| | | def test_resource_url_root_default(self): |
| | |
| | | context = DummyContext() |
| | | result = request.resource_url(context, 'this/theotherthing', 'that') |
| | | self.assertEqual( |
| | | result, |
| | | 'http://example.com:5432/context/this%2Ftheotherthing/that') |
| | | result, 'http://example.com:5432/context/this%2Ftheotherthing/that' |
| | | ) |
| | | |
| | | def test_resource_url_unicode_in_element_names(self): |
| | | request = self._makeOne() |
| | |
| | | uc = text_(b'La Pe\xc3\xb1a', 'utf-8') |
| | | context = DummyContext() |
| | | result = request.resource_url(context, uc) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/La%20Pe%C3%B1a') |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/context/La%20Pe%C3%B1a' |
| | | ) |
| | | |
| | | def test_resource_url_at_sign_in_element_names(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | result = request.resource_url(context, '@@myview') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/@@myview') |
| | | self.assertEqual(result, 'http://example.com:5432/context/@@myview') |
| | | |
| | | def test_resource_url_element_names_url_quoted(self): |
| | | request = self._makeOne() |
| | |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | result = request.resource_url(context, 'a', query='(openlayers)') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/a?(openlayers)') |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/context/a?(openlayers)' |
| | | ) |
| | | |
| | | def test_resource_url_with_query_dict(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | uc = text_(b'La Pe\xc3\xb1a', 'utf-8') |
| | | result = request.resource_url(context, 'a', query={'a':uc}) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/a?a=La+Pe%C3%B1a') |
| | | result = request.resource_url(context, 'a', query={'a': uc}) |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/context/a?a=La+Pe%C3%B1a' |
| | | ) |
| | | |
| | | def test_resource_url_with_query_seq(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | uc = text_(b'La Pe\xc3\xb1a', 'utf-8') |
| | | result = request.resource_url(context, 'a', query=[('a', 'hi there'), |
| | | ('b', uc)]) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/a?a=hi+there&b=La+Pe%C3%B1a') |
| | | result = request.resource_url( |
| | | context, 'a', query=[('a', 'hi there'), ('b', uc)] |
| | | ) |
| | | self.assertEqual( |
| | | result, |
| | | 'http://example.com:5432/context/a?a=hi+there&b=La+Pe%C3%B1a', |
| | | ) |
| | | |
| | | def test_resource_url_with_query_empty(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | result = request.resource_url(context, 'a', query=[]) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/a') |
| | | self.assertEqual(result, 'http://example.com:5432/context/a') |
| | | |
| | | def test_resource_url_with_query_None(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | result = request.resource_url(context, 'a', query=None) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/a') |
| | | self.assertEqual(result, 'http://example.com:5432/context/a') |
| | | |
| | | def test_resource_url_anchor_is_after_root_when_no_elements(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | result = request.resource_url(context, anchor='a') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/#a') |
| | | self.assertEqual(result, 'http://example.com:5432/context/#a') |
| | | |
| | | def test_resource_url_anchor_is_after_elements_when_no_qs(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | result = request.resource_url(context, 'a', anchor='b') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/a#b') |
| | | self.assertEqual(result, 'http://example.com:5432/context/a#b') |
| | | |
| | | def test_resource_url_anchor_is_after_qs_when_qs_is_present(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | result = request.resource_url(context, 'a', |
| | | query={'b':'c'}, anchor='d') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/a?b=c#d') |
| | | result = request.resource_url( |
| | | context, 'a', query={'b': 'c'}, anchor='d' |
| | | ) |
| | | self.assertEqual(result, 'http://example.com:5432/context/a?b=c#d') |
| | | |
| | | def test_resource_url_anchor_is_encoded_utf8_if_unicode(self): |
| | | request = self._makeOne() |
| | |
| | | context = DummyContext() |
| | | uc = text_(b'La Pe\xc3\xb1a', 'utf-8') |
| | | result = request.resource_url(context, anchor=uc) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/#La%20Pe%C3%B1a') |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/context/#La%20Pe%C3%B1a' |
| | | ) |
| | | |
| | | def test_resource_url_anchor_is_urlencoded_safe(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | | context = DummyContext() |
| | | result = request.resource_url(context, anchor=' /#?&+') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/context/#%20/%23?&+') |
| | | self.assertEqual(result, 'http://example.com:5432/context/#%20/%23?&+') |
| | | |
| | | def test_resource_url_anchor_is_None(self): |
| | | request = self._makeOne() |
| | |
| | | root = DummyContext() |
| | | result = request.resource_url(root) |
| | | self.assertEqual(result, 'http://example.com:5432/context/') |
| | | |
| | | |
| | | def test_resource_url_with_app_url(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | |
| | | |
| | | def test_resource_url_with_scheme(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | self._registerResourceURL(request.registry) |
| | | root = DummyContext() |
| | |
| | | |
| | | def test_resource_url_with_host(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | self._registerResourceURL(request.registry) |
| | | root = DummyContext() |
| | |
| | | |
| | | def test_resource_url_with_port(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | self._registerResourceURL(request.registry) |
| | | root = DummyContext() |
| | |
| | | |
| | | def test_resource_url_with_local_url(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | self._registerResourceURL(request.registry) |
| | | root = DummyContext() |
| | | |
| | | def resource_url(req, info): |
| | | self.assertEqual(req, request) |
| | | self.assertEqual(info['virtual_path'], '/context/') |
| | | self.assertEqual(info['physical_path'], '/context/') |
| | | self.assertEqual(info['app_url'], 'http://example.com:5432') |
| | | return 'http://example.com/contextabc/' |
| | | |
| | | root.__resource_url__ = resource_url |
| | | result = request.resource_url(root) |
| | | self.assertEqual(result, 'http://example.com/contextabc/') |
| | | |
| | | def test_resource_url_with_route_name_no_remainder_on_adapter(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | adapter = self._registerResourceURL(request.registry) |
| | | # no virtual_path_tuple on adapter |
| | |
| | | |
| | | def test_resource_url_with_route_name_remainder_on_adapter(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | adapter = self._registerResourceURL(request.registry) |
| | | # virtual_path_tuple on adapter |
| | |
| | | |
| | | def test_resource_url_with_route_name_and_app_url(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | adapter = self._registerResourceURL(request.registry) |
| | | # virtual_path_tuple on adapter |
| | | adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '') |
| | | route = DummyRoute('/1/2/3') |
| | | mapper = DummyRoutesMapper(route) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | root = DummyContext() |
| | | result = request.resource_url(root, route_name='foo', app_url='app_url') |
| | | self.assertEqual(result, 'app_url/1/2/3') |
| | | self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')}) |
| | | |
| | | def test_resource_url_with_route_name_and_scheme_host_port_etc(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | adapter = self._registerResourceURL(request.registry) |
| | | # virtual_path_tuple on adapter |
| | | adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '') |
| | | route = DummyRoute('/1/2/3') |
| | | mapper = DummyRoutesMapper(route) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | root = DummyContext() |
| | | result = request.resource_url(root, route_name='foo', scheme='scheme', |
| | | host='host', port='port', query={'a':'1'}, |
| | | anchor='anchor') |
| | | self.assertEqual(result, 'scheme://host:port/1/2/3?a=1#anchor') |
| | | self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')}) |
| | | |
| | | def test_resource_url_with_route_name_and_route_kwargs(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | adapter = self._registerResourceURL(request.registry) |
| | | # virtual_path_tuple on adapter |
| | |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | root = DummyContext() |
| | | result = request.resource_url( |
| | | root, route_name='foo', route_kw={'a':'1', 'b':'2'}) |
| | | root, route_name='foo', app_url='app_url' |
| | | ) |
| | | self.assertEqual(result, 'app_url/1/2/3') |
| | | self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')}) |
| | | |
| | | def test_resource_url_with_route_name_and_scheme_host_port_etc(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | environ = { |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | adapter = self._registerResourceURL(request.registry) |
| | | # virtual_path_tuple on adapter |
| | | adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '') |
| | | route = DummyRoute('/1/2/3') |
| | | mapper = DummyRoutesMapper(route) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | root = DummyContext() |
| | | result = request.resource_url( |
| | | root, |
| | | route_name='foo', |
| | | scheme='scheme', |
| | | host='host', |
| | | port='port', |
| | | query={'a': '1'}, |
| | | anchor='anchor', |
| | | ) |
| | | self.assertEqual(result, 'scheme://host:port/1/2/3?a=1#anchor') |
| | | self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')}) |
| | | |
| | | def test_resource_url_with_route_name_and_route_kwargs(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | environ = { |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | adapter = self._registerResourceURL(request.registry) |
| | | # virtual_path_tuple on adapter |
| | | adapter.virtual_path_tuple = ('', 'a', 'b', 'c', '') |
| | | route = DummyRoute('/1/2/3') |
| | | mapper = DummyRoutesMapper(route) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | root = DummyContext() |
| | | result = request.resource_url( |
| | | root, route_name='foo', route_kw={'a': '1', 'b': '2'} |
| | | ) |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3') |
| | | self.assertEqual( |
| | | route.kw, |
| | | {'traverse': ('', 'a', 'b', 'c', ''), |
| | | 'a':'1', |
| | | 'b':'2'} |
| | | ) |
| | | route.kw, {'traverse': ('', 'a', 'b', 'c', ''), 'a': '1', 'b': '2'} |
| | | ) |
| | | |
| | | def test_resource_url_with_route_name_and_elements(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | adapter = self._registerResourceURL(request.registry) |
| | | # virtual_path_tuple on adapter |
| | |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | root = DummyContext() |
| | | result = request.resource_url(root, 'e1', 'e2', route_name='foo') |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3/e1/e2') |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3/e1/e2') |
| | | self.assertEqual(route.kw, {'traverse': ('', 'a', 'b', 'c', '')}) |
| | | |
| | | |
| | | def test_resource_url_with_route_name_and_remainder_name(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'8080', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '8080', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | adapter = self._registerResourceURL(request.registry) |
| | | # virtual_path_tuple on adapter |
| | |
| | | mapper = DummyRoutesMapper(route) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | root = DummyContext() |
| | | result = request.resource_url(root, route_name='foo', |
| | | route_remainder_name='fred') |
| | | result = request.resource_url( |
| | | root, route_name='foo', route_remainder_name='fred' |
| | | ) |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3') |
| | | self.assertEqual(route.kw, {'fred': ('', 'a', 'b', 'c', '')}) |
| | | |
| | | |
| | | def test_resource_path(self): |
| | | request = self._makeOne() |
| | | self._registerResourceURL(request.registry) |
| | |
| | | root = DummyContext() |
| | | result = request.resource_path(root, anchor='abc') |
| | | self.assertEqual(result, '/context/#abc') |
| | | |
| | | |
| | | def test_route_url_with_elements(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', 'extra1', 'extra2') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3/extra1/extra2') |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3/extra1/extra2') |
| | | |
| | | def test_route_url_with_elements_path_endswith_slash(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3/')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', 'extra1', 'extra2') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3/extra1/extra2') |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3/extra1/extra2') |
| | | |
| | | def test_route_url_no_elements(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', a=1, b=2, c=3, _query={'a':1}, |
| | | _anchor=text_(b"foo")) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3?a=1#foo') |
| | | result = request.route_url( |
| | | 'flub', a=1, b=2, c=3, _query={'a': 1}, _anchor=text_(b"foo") |
| | | ) |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3?a=1#foo') |
| | | |
| | | def test_route_url_with_query_None(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | |
| | | |
| | | def test_route_url_with_anchor_binary(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', _anchor=b"La Pe\xc3\xb1a") |
| | | |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3#La%20Pe%C3%B1a') |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/1/2/3#La%20Pe%C3%B1a' |
| | | ) |
| | | |
| | | 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, |
| | | 'http://example.com:5432/1/2/3#La%20Pe%C3%B1a') |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/1/2/3#La%20Pe%C3%B1a' |
| | | ) |
| | | |
| | | def test_route_url_with_anchor_None(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | |
| | | |
| | | def test_route_url_with_query(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', _query={'q':'1'}) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3?q=1') |
| | | result = request.route_url('flub', _query={'q': '1'}) |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3?q=1') |
| | | |
| | | def test_route_url_with_query_str(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', _query='(openlayers)') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3?(openlayers)') |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3?(openlayers)') |
| | | |
| | | def test_route_url_with_empty_query(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', _query={}) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3') |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3') |
| | | |
| | | def test_route_url_with_app_url(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', _app_url='http://example2.com') |
| | | self.assertEqual(result, |
| | | 'http://example2.com/1/2/3') |
| | | self.assertEqual(result, 'http://example2.com/1/2/3') |
| | | |
| | | def test_route_url_with_host(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'5432', |
| | | } |
| | | |
| | | environ = {'wsgi.url_scheme': 'http', 'SERVER_PORT': '5432'} |
| | | request = self._makeOne(environ) |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', _host='someotherhost.com') |
| | | self.assertEqual(result, |
| | | 'http://someotherhost.com:5432/1/2/3') |
| | | self.assertEqual(result, 'http://someotherhost.com:5432/1/2/3') |
| | | |
| | | def test_route_url_with_port(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'5432', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '5432', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', _port='8080') |
| | | self.assertEqual(result, |
| | | 'http://example.com:8080/1/2/3') |
| | | self.assertEqual(result, 'http://example.com:8080/1/2/3') |
| | | |
| | | def test_route_url_with_scheme(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_PORT':'5432', |
| | | 'SERVER_NAME':'example.com', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_PORT': '5432', |
| | | 'SERVER_NAME': 'example.com', |
| | | } |
| | | request = self._makeOne(environ) |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', _scheme='https') |
| | | self.assertEqual(result, |
| | | 'https://example.com/1/2/3') |
| | | |
| | | self.assertEqual(result, 'https://example.com/1/2/3') |
| | | |
| | | def test_route_url_generation_error(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(raise_exc=KeyError) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | |
| | | |
| | | def test_route_url_generate_doesnt_receive_query_or_anchor(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | route = DummyRoute(result='') |
| | | mapper = DummyRoutesMapper(route=route) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', _query=dict(name='some_name')) |
| | | self.assertEqual(route.kw, {}) # shouldnt have anchor/query |
| | | self.assertEqual(route.kw, {}) # shouldnt have anchor/query |
| | | self.assertEqual(result, 'http://example.com:5432?name=some_name') |
| | | |
| | | def test_route_url_with_pregenerator(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | route = DummyRoute(result='/1/2/3') |
| | | |
| | | def pregenerator(request, elements, kw): |
| | | return ('a',), {'_app_url':'http://example2.com'} |
| | | return ('a',), {'_app_url': 'http://example2.com'} |
| | | |
| | | route.pregenerator = pregenerator |
| | | mapper = DummyRoutesMapper(route=route) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub') |
| | | self.assertEqual(result, 'http://example2.com/1/2/3/a') |
| | | self.assertEqual(route.kw, {}) # shouldnt have anchor/query |
| | | self.assertEqual(result, 'http://example2.com/1/2/3/a') |
| | | self.assertEqual(route.kw, {}) # shouldnt have anchor/query |
| | | |
| | | def test_route_url_with_anchor_app_url_elements_and_query(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute(result='/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', 'element1', |
| | | _app_url='http://example2.com', |
| | | _anchor='anchor', _query={'q':'1'}) |
| | | self.assertEqual(result, |
| | | 'http://example2.com/1/2/3/element1?q=1#anchor') |
| | | result = request.route_url( |
| | | 'flub', |
| | | 'element1', |
| | | _app_url='http://example2.com', |
| | | _anchor='anchor', |
| | | _query={'q': '1'}, |
| | | ) |
| | | self.assertEqual( |
| | | result, 'http://example2.com/1/2/3/element1?q=1#anchor' |
| | | ) |
| | | |
| | | def test_route_url_integration_with_real_request(self): |
| | | # to try to replicate https://github.com/Pylons/pyramid/issues/213 |
| | | from pyramid.interfaces import IRoutesMapper |
| | | from pyramid.request import Request |
| | | |
| | | request = Request.blank('/') |
| | | request.registry = self.config.registry |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_url('flub', 'extra1', 'extra2') |
| | | self.assertEqual(result, |
| | | 'http://localhost/1/2/3/extra1/extra2') |
| | | |
| | | self.assertEqual(result, 'http://localhost/1/2/3/extra1/extra2') |
| | | |
| | | def test_current_route_url_current_request_has_no_route(self): |
| | | request = self._makeOne() |
| | |
| | | |
| | | def test_current_route_url_with_elements_query_and_anchor(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | route = DummyRoute('/1/2/3') |
| | | mapper = DummyRoutesMapper(route=route) |
| | | request.matched_route = route |
| | | request.matchdict = {} |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.current_route_url('extra1', 'extra2', _query={'a':1}, |
| | | _anchor=text_(b"foo")) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo') |
| | | result = request.current_route_url( |
| | | 'extra1', 'extra2', _query={'a': 1}, _anchor=text_(b"foo") |
| | | ) |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo' |
| | | ) |
| | | |
| | | def test_current_route_url_with_route_name(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | route = DummyRoute('/1/2/3') |
| | | mapper = DummyRoutesMapper(route=route) |
| | | request.matched_route = route |
| | | request.matchdict = {} |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.current_route_url('extra1', 'extra2', _query={'a':1}, |
| | | _anchor=text_(b"foo"), |
| | | _route_name='bar') |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo') |
| | | result = request.current_route_url( |
| | | 'extra1', |
| | | 'extra2', |
| | | _query={'a': 1}, |
| | | _anchor=text_(b"foo"), |
| | | _route_name='bar', |
| | | ) |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo' |
| | | ) |
| | | |
| | | def test_current_route_url_with_request_query(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | from webob.multidict import GetDict |
| | | |
| | | request = self._makeOne() |
| | | request.GET = GetDict([('q', '123')], {}) |
| | | route = DummyRoute('/1/2/3') |
| | |
| | | request.matchdict = {} |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.current_route_url() |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3?q=123') |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3?q=123') |
| | | |
| | | def test_current_route_url_with_request_query_duplicate_entries(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | from webob.multidict import GetDict |
| | | |
| | | request = self._makeOne() |
| | | request.GET = GetDict( |
| | | [('q', '123'), ('b', '2'), ('b', '2'), ('q', '456')], {}) |
| | | [('q', '123'), ('b', '2'), ('b', '2'), ('q', '456')], {} |
| | | ) |
| | | route = DummyRoute('/1/2/3') |
| | | mapper = DummyRoutesMapper(route=route) |
| | | request.matched_route = route |
| | | request.matchdict = {} |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.current_route_url() |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3?q=123&b=2&b=2&q=456') |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/1/2/3?q=123&b=2&b=2&q=456' |
| | | ) |
| | | |
| | | def test_current_route_url_with_query_override(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | from webob.multidict import GetDict |
| | | |
| | | request = self._makeOne() |
| | | request.GET = GetDict([('q', '123')], {}) |
| | | route = DummyRoute('/1/2/3') |
| | |
| | | request.matched_route = route |
| | | request.matchdict = {} |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.current_route_url(_query={'a':1}) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/1/2/3?a=1') |
| | | result = request.current_route_url(_query={'a': 1}) |
| | | self.assertEqual(result, 'http://example.com:5432/1/2/3?a=1') |
| | | |
| | | def test_current_route_path(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | route = DummyRoute('/1/2/3') |
| | | mapper = DummyRoutesMapper(route=route) |
| | |
| | | request.matchdict = {} |
| | | request.script_name = '/script_name' |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.current_route_path('extra1', 'extra2', _query={'a':1}, |
| | | _anchor=text_(b"foo")) |
| | | result = request.current_route_path( |
| | | 'extra1', 'extra2', _query={'a': 1}, _anchor=text_(b"foo") |
| | | ) |
| | | self.assertEqual(result, '/script_name/1/2/3/extra1/extra2?a=1#foo') |
| | | |
| | | def test_route_path_with_elements(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | request.script_name = '' |
| | | result = request.route_path('flub', 'extra1', 'extra2', |
| | | a=1, b=2, c=3, _query={'a':1}, |
| | | _anchor=text_(b"foo")) |
| | | result = request.route_path( |
| | | 'flub', |
| | | 'extra1', |
| | | 'extra2', |
| | | a=1, |
| | | b=2, |
| | | c=3, |
| | | _query={'a': 1}, |
| | | _anchor=text_(b"foo"), |
| | | ) |
| | | self.assertEqual(result, '/1/2/3/extra1/extra2?a=1#foo') |
| | | |
| | | def test_route_path_with_script_name(self): |
| | | from pyramid.interfaces import IRoutesMapper |
| | | |
| | | request = self._makeOne() |
| | | request.script_name = '/foo' |
| | | mapper = DummyRoutesMapper(route=DummyRoute('/1/2/3')) |
| | | request.registry.registerUtility(mapper, IRoutesMapper) |
| | | result = request.route_path('flub', 'extra1', 'extra2', |
| | | a=1, b=2, c=3, _query={'a':1}, |
| | | _anchor=text_(b"foo")) |
| | | result = request.route_path( |
| | | 'flub', |
| | | 'extra1', |
| | | 'extra2', |
| | | a=1, |
| | | b=2, |
| | | c=3, |
| | | _query={'a': 1}, |
| | | _anchor=text_(b"foo"), |
| | | ) |
| | | self.assertEqual(result, '/foo/1/2/3/extra1/extra2?a=1#foo') |
| | | |
| | | |
| | | def test_static_url_staticurlinfo_notfound(self): |
| | | request = self._makeOne() |
| | | self.assertRaises(ValueError, request.static_url, 'static/foo.css') |
| | | |
| | | def test_static_url_abspath(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | |
| | | request = self._makeOne() |
| | | info = DummyStaticURLInfo('abc') |
| | | registry = request.registry |
| | |
| | | abspath = makeabs('static', 'foo.css') |
| | | result = request.static_url(abspath) |
| | | self.assertEqual(result, 'abc') |
| | | self.assertEqual(info.args, (makeabs('static', 'foo.css'), request, {})) |
| | | self.assertEqual( |
| | | info.args, (makeabs('static', 'foo.css'), request, {}) |
| | | ) |
| | | request = self._makeOne() |
| | | |
| | | def test_static_url_found_rel(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | |
| | | request = self._makeOne() |
| | | info = DummyStaticURLInfo('abc') |
| | | request.registry.registerUtility(info, IStaticURLInfo) |
| | | result = request.static_url('static/foo.css') |
| | | self.assertEqual(result, 'abc') |
| | | self.assertEqual(info.args, |
| | | ('tests:static/foo.css', request, {}) ) |
| | | self.assertEqual(info.args, ('tests:static/foo.css', request, {})) |
| | | |
| | | def test_static_url_abs(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | |
| | | request = self._makeOne() |
| | | info = DummyStaticURLInfo('abc') |
| | | request.registry.registerUtility(info, IStaticURLInfo) |
| | | result = request.static_url('tests:static/foo.css') |
| | | self.assertEqual(result, 'abc') |
| | | self.assertEqual(info.args, |
| | | ('tests:static/foo.css', request, {}) ) |
| | | self.assertEqual(info.args, ('tests:static/foo.css', request, {})) |
| | | |
| | | def test_static_url_found_abs_no_registry_on_request(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | |
| | | request = self._makeOne() |
| | | registry = request.registry |
| | | info = DummyStaticURLInfo('abc') |
| | |
| | | del request.registry |
| | | result = request.static_url('tests:static/foo.css') |
| | | self.assertEqual(result, 'abc') |
| | | self.assertEqual(info.args, |
| | | ('tests:static/foo.css', request, {}) ) |
| | | self.assertEqual(info.args, ('tests:static/foo.css', request, {})) |
| | | |
| | | def test_static_url_abspath_integration_with_staticurlinfo(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | from pyramid.config.views import StaticURLInfo |
| | | |
| | | info = StaticURLInfo() |
| | | here = os.path.abspath(os.path.dirname(__file__)) |
| | | info.add(self.config, 'absstatic', here) |
| | |
| | | registry.registerUtility(info, IStaticURLInfo) |
| | | abspath = os.path.join(here, 'test_url.py') |
| | | result = request.static_url(abspath) |
| | | self.assertEqual(result, |
| | | 'http://example.com:5432/absstatic/test_url.py') |
| | | self.assertEqual( |
| | | result, 'http://example.com:5432/absstatic/test_url.py' |
| | | ) |
| | | |
| | | def test_static_url_noscheme_uses_scheme_from_request(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | from pyramid.config.views import StaticURLInfo |
| | | |
| | | info = StaticURLInfo() |
| | | here = os.path.abspath(os.path.dirname(__file__)) |
| | | info.add(self.config, '//subdomain.example.com/static', here) |
| | |
| | | registry.registerUtility(info, IStaticURLInfo) |
| | | abspath = os.path.join(here, 'test_url.py') |
| | | result = request.static_url(abspath) |
| | | self.assertEqual(result, |
| | | 'https://subdomain.example.com/static/test_url.py') |
| | | self.assertEqual( |
| | | result, 'https://subdomain.example.com/static/test_url.py' |
| | | ) |
| | | |
| | | def test_static_path_abspath(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | |
| | | request = self._makeOne() |
| | | request.script_name = '/foo' |
| | | info = DummyStaticURLInfo('abc') |
| | |
| | | abspath = makeabs('static', 'foo.css') |
| | | result = request.static_path(abspath) |
| | | self.assertEqual(result, 'abc') |
| | | self.assertEqual(info.args, (makeabs('static', 'foo.css'), request, |
| | | {'_app_url':'/foo'}) |
| | | ) |
| | | self.assertEqual( |
| | | info.args, |
| | | (makeabs('static', 'foo.css'), request, {'_app_url': '/foo'}), |
| | | ) |
| | | |
| | | def test_static_path_found_rel(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | |
| | | request = self._makeOne() |
| | | request.script_name = '/foo' |
| | | info = DummyStaticURLInfo('abc') |
| | | request.registry.registerUtility(info, IStaticURLInfo) |
| | | result = request.static_path('static/foo.css') |
| | | self.assertEqual(result, 'abc') |
| | | self.assertEqual(info.args, |
| | | ('tests:static/foo.css', request, |
| | | {'_app_url':'/foo'}) |
| | | ) |
| | | self.assertEqual( |
| | | info.args, ('tests:static/foo.css', request, {'_app_url': '/foo'}) |
| | | ) |
| | | |
| | | def test_static_path_abs(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | |
| | | request = self._makeOne() |
| | | request.script_name = '/foo' |
| | | info = DummyStaticURLInfo('abc') |
| | | request.registry.registerUtility(info, IStaticURLInfo) |
| | | result = request.static_path('tests:static/foo.css') |
| | | self.assertEqual(result, 'abc') |
| | | self.assertEqual(info.args, |
| | | ('tests:static/foo.css', request, |
| | | {'_app_url':'/foo'}) |
| | | ) |
| | | self.assertEqual( |
| | | info.args, ('tests:static/foo.css', request, {'_app_url': '/foo'}) |
| | | ) |
| | | |
| | | def test_static_path(self): |
| | | from pyramid.interfaces import IStaticURLInfo |
| | | |
| | | request = self._makeOne() |
| | | request.script_name = '/foo' |
| | | info = DummyStaticURLInfo('abc') |
| | | request.registry.registerUtility(info, IStaticURLInfo) |
| | | result = request.static_path('static/foo.css') |
| | | self.assertEqual(result, 'abc') |
| | | self.assertEqual(info.args, |
| | | ('tests:static/foo.css', request, |
| | | {'_app_url':'/foo'}) |
| | | ) |
| | | self.assertEqual( |
| | | info.args, ('tests:static/foo.css', request, {'_app_url': '/foo'}) |
| | | ) |
| | | |
| | | def test_partial_application_url_with_http_host_default_port_http(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'HTTP_HOST':'example.com:80', |
| | | } |
| | | environ = {'wsgi.url_scheme': 'http', 'HTTP_HOST': 'example.com:80'} |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url() |
| | | self.assertEqual(result, 'http://example.com') |
| | | |
| | | def test_partial_application_url_with_http_host_default_port_https(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'https', |
| | | 'HTTP_HOST':'example.com:443', |
| | | } |
| | | environ = {'wsgi.url_scheme': 'https', 'HTTP_HOST': 'example.com:443'} |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url() |
| | | self.assertEqual(result, 'https://example.com') |
| | | |
| | | def test_partial_application_url_with_http_host_nondefault_port_http(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'HTTP_HOST':'example.com:8080', |
| | | } |
| | | environ = {'wsgi.url_scheme': 'http', 'HTTP_HOST': 'example.com:8080'} |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url() |
| | | self.assertEqual(result, 'http://example.com:8080') |
| | | |
| | | def test_partial_application_url_with_http_host_nondefault_port_https(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'https', |
| | | 'HTTP_HOST':'example.com:4443', |
| | | } |
| | | def test_partial_application_url_with_http_host_nondefault_port_https( |
| | | self |
| | | ): |
| | | environ = {'wsgi.url_scheme': 'https', 'HTTP_HOST': 'example.com:4443'} |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url() |
| | | self.assertEqual(result, 'https://example.com:4443') |
| | | |
| | | def test_partial_application_url_with_http_host_no_colon(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'HTTP_HOST':'example.com', |
| | | 'SERVER_PORT':'80', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'HTTP_HOST': 'example.com', |
| | | 'SERVER_PORT': '80', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url() |
| | | self.assertEqual(result, 'http://example.com') |
| | | |
| | | def test_partial_application_url_no_http_host(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'80', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '80', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url() |
| | | self.assertEqual(result, 'http://example.com') |
| | | |
| | | |
| | | def test_partial_application_replace_port(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'80', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '80', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url(port=8080) |
| | | self.assertEqual(result, 'http://example.com:8080') |
| | | |
| | | def test_partial_application_replace_scheme_https_special_case(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'80', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '80', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url(scheme='https') |
| | | self.assertEqual(result, 'https://example.com') |
| | | |
| | | def test_partial_application_replace_scheme_https_special_case_avoid(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'80', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '80', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url(scheme='https', port='8080') |
| | | self.assertEqual(result, 'https://example.com:8080') |
| | | |
| | | def test_partial_application_replace_scheme_http_special_case(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'https', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'8080', |
| | | } |
| | | 'wsgi.url_scheme': 'https', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '8080', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url(scheme='http') |
| | | self.assertEqual(result, 'http://example.com') |
| | | |
| | | def test_partial_application_replace_scheme_http_special_case_avoid(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'https', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'8000', |
| | | } |
| | | 'wsgi.url_scheme': 'https', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '8000', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url(scheme='http', port='8080') |
| | | self.assertEqual(result, 'http://example.com:8080') |
| | | |
| | | |
| | | def test_partial_application_replace_host_no_port(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'80', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '80', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url(host='someotherhost.com') |
| | | self.assertEqual(result, 'http://someotherhost.com') |
| | | |
| | | def test_partial_application_replace_host_with_port(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'8000', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '8000', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url(host='someotherhost.com:8080') |
| | | result = request._partial_application_url( |
| | | host='someotherhost.com:8080' |
| | | ) |
| | | self.assertEqual(result, 'http://someotherhost.com:8080') |
| | | |
| | | def test_partial_application_replace_host_and_port(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'80', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '80', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url(host='someotherhost.com:8080', |
| | | port='8000') |
| | | result = request._partial_application_url( |
| | | host='someotherhost.com:8080', port='8000' |
| | | ) |
| | | self.assertEqual(result, 'http://someotherhost.com:8000') |
| | | |
| | | def test_partial_application_replace_host_port_and_scheme(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'80', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '80', |
| | | } |
| | | request = self._makeOne(environ) |
| | | result = request._partial_application_url( |
| | | host='someotherhost.com:8080', |
| | | port='8000', |
| | | scheme='https', |
| | | ) |
| | | host='someotherhost.com:8080', port='8000', scheme='https' |
| | | ) |
| | | self.assertEqual(result, 'https://someotherhost.com:8000') |
| | | |
| | | |
| | | def test_partial_application_url_with_custom_script_name(self): |
| | | environ = { |
| | | 'wsgi.url_scheme':'http', |
| | | 'SERVER_NAME':'example.com', |
| | | 'SERVER_PORT':'8000', |
| | | } |
| | | 'wsgi.url_scheme': 'http', |
| | | 'SERVER_NAME': 'example.com', |
| | | 'SERVER_PORT': '8000', |
| | | } |
| | | request = self._makeOne(environ) |
| | | request.script_name = '/abc' |
| | | result = request._partial_application_url() |
| | | self.assertEqual(result, 'http://example.com:8000/abc') |
| | | |
| | | self.assertEqual(result, 'http://example.com:8000/abc') |
| | | |
| | | |
| | | class Test_route_url(unittest.TestCase): |
| | | def _callFUT(self, route_name, request, *elements, **kw): |
| | | from pyramid.url import route_url |
| | | |
| | | return route_url(route_name, request, *elements, **kw) |
| | | |
| | | def _makeRequest(self): |
| | |
| | | self.elements = elements |
| | | self.kw = kw |
| | | return 'route url' |
| | | |
| | | return Request() |
| | | |
| | | def test_it(self): |
| | |
| | | self.assertEqual(result, 'route url') |
| | | self.assertEqual(request.route_name, 'abc') |
| | | self.assertEqual(request.elements, ('a',)) |
| | | self.assertEqual(request.kw, {'_app_url':''}) |
| | | self.assertEqual(request.kw, {'_app_url': ''}) |
| | | |
| | | |
| | | class Test_route_path(unittest.TestCase): |
| | | def _callFUT(self, route_name, request, *elements, **kw): |
| | | from pyramid.url import route_path |
| | | |
| | | return route_path(route_name, request, *elements, **kw) |
| | | |
| | | def _makeRequest(self): |
| | |
| | | self.elements = elements |
| | | self.kw = kw |
| | | return 'route path' |
| | | |
| | | return Request() |
| | | |
| | | def test_it(self): |
| | |
| | | self.assertEqual(result, 'route path') |
| | | self.assertEqual(request.route_name, 'abc') |
| | | self.assertEqual(request.elements, ('a',)) |
| | | self.assertEqual(request.kw, {'_app_url':''}) |
| | | self.assertEqual(request.kw, {'_app_url': ''}) |
| | | |
| | | |
| | | class Test_resource_url(unittest.TestCase): |
| | | def _callFUT(self, resource, request, *elements, **kw): |
| | | from pyramid.url import resource_url |
| | | |
| | | return resource_url(resource, request, *elements, **kw) |
| | | |
| | | def _makeRequest(self): |
| | |
| | | self.elements = elements |
| | | self.kw = kw |
| | | return 'resource url' |
| | | |
| | | return Request() |
| | | |
| | | def test_it(self): |
| | |
| | | self.assertEqual(result, 'resource url') |
| | | self.assertEqual(request.resource, 'abc') |
| | | self.assertEqual(request.elements, ('a',)) |
| | | self.assertEqual(request.kw, {'_app_url':''}) |
| | | self.assertEqual(request.kw, {'_app_url': ''}) |
| | | |
| | | |
| | | class Test_static_url(unittest.TestCase): |
| | | def _callFUT(self, path, request, **kw): |
| | | from pyramid.url import static_url |
| | | |
| | | return static_url(path, request, **kw) |
| | | |
| | | def _makeRequest(self): |
| | |
| | | self.path = path |
| | | self.kw = kw |
| | | return 'static url' |
| | | |
| | | return Request() |
| | | |
| | | def test_it_abs(self): |
| | |
| | | result = self._callFUT('/foo/bar/abc', request, _app_url='') |
| | | self.assertEqual(result, 'static url') |
| | | self.assertEqual(request.path, '/foo/bar/abc') |
| | | self.assertEqual(request.kw, {'_app_url':''}) |
| | | self.assertEqual(request.kw, {'_app_url': ''}) |
| | | |
| | | def test_it_absspec(self): |
| | | request = self._makeRequest() |
| | | result = self._callFUT('foo:abc', request, _anchor='anchor') |
| | | self.assertEqual(result, 'static url') |
| | | self.assertEqual(request.path, 'foo:abc') |
| | | self.assertEqual(request.kw, {'_anchor':'anchor'}) |
| | | self.assertEqual(request.kw, {'_anchor': 'anchor'}) |
| | | |
| | | def test_it_rel(self): |
| | | request = self._makeRequest() |
| | | result = self._callFUT('abc', request, _app_url='') |
| | | self.assertEqual(result, 'static url') |
| | | self.assertEqual(request.path, 'tests:abc') |
| | | self.assertEqual(request.kw, {'_app_url':''}) |
| | | self.assertEqual(request.kw, {'_app_url': ''}) |
| | | |
| | | |
| | | class Test_static_path(unittest.TestCase): |
| | | def _callFUT(self, path, request, **kw): |
| | | from pyramid.url import static_path |
| | | |
| | | return static_path(path, request, **kw) |
| | | |
| | | def _makeRequest(self): |
| | |
| | | self.path = path |
| | | self.kw = kw |
| | | return 'static path' |
| | | |
| | | return Request() |
| | | |
| | | def test_it_abs(self): |
| | |
| | | result = self._callFUT('/foo/bar/abc', request, _anchor='anchor') |
| | | self.assertEqual(result, 'static path') |
| | | self.assertEqual(request.path, '/foo/bar/abc') |
| | | self.assertEqual(request.kw, {'_anchor':'anchor'}) |
| | | self.assertEqual(request.kw, {'_anchor': 'anchor'}) |
| | | |
| | | def test_it_absspec(self): |
| | | request = self._makeRequest() |
| | | result = self._callFUT('foo:abc', request, _anchor='anchor') |
| | | self.assertEqual(result, 'static path') |
| | | self.assertEqual(request.path, 'foo:abc') |
| | | self.assertEqual(request.kw, {'_anchor':'anchor'}) |
| | | self.assertEqual(request.kw, {'_anchor': 'anchor'}) |
| | | |
| | | def test_it_rel(self): |
| | | request = self._makeRequest() |
| | | result = self._callFUT('abc', request, _app_url='') |
| | | self.assertEqual(result, 'static path') |
| | | self.assertEqual(request.path, 'tests:abc') |
| | | self.assertEqual(request.kw, {'_app_url':''}) |
| | | self.assertEqual(request.kw, {'_app_url': ''}) |
| | | |
| | | |
| | | class Test_current_route_url(unittest.TestCase): |
| | | def _callFUT(self, request, *elements, **kw): |
| | | from pyramid.url import current_route_url |
| | | |
| | | return current_route_url(request, *elements, **kw) |
| | | |
| | | def _makeRequest(self): |
| | |
| | | self.elements = elements |
| | | self.kw = kw |
| | | return 'current route url' |
| | | |
| | | return Request() |
| | | |
| | | def test_it(self): |
| | |
| | | result = self._callFUT(request, 'abc', _app_url='') |
| | | self.assertEqual(result, 'current route url') |
| | | self.assertEqual(request.elements, ('abc',)) |
| | | self.assertEqual(request.kw, {'_app_url':''}) |
| | | self.assertEqual(request.kw, {'_app_url': ''}) |
| | | |
| | | |
| | | class Test_current_route_path(unittest.TestCase): |
| | | def _callFUT(self, request, *elements, **kw): |
| | | from pyramid.url import current_route_path |
| | | |
| | | return current_route_path(request, *elements, **kw) |
| | | |
| | | def _makeRequest(self): |
| | |
| | | self.elements = elements |
| | | self.kw = kw |
| | | return 'current route path' |
| | | |
| | | return Request() |
| | | |
| | | def test_it(self): |
| | |
| | | result = self._callFUT(request, 'abc', _anchor='abc') |
| | | self.assertEqual(result, 'current route path') |
| | | self.assertEqual(request.elements, ('abc',)) |
| | | self.assertEqual(request.kw, {'_anchor':'abc'}) |
| | | self.assertEqual(request.kw, {'_anchor': 'abc'}) |
| | | |
| | | |
| | | class Test_external_static_url_integration(unittest.TestCase): |
| | | |
| | | def setUp(self): |
| | | self.config = testing.setUp() |
| | | |
| | |
| | | |
| | | def _makeRequest(self): |
| | | from pyramid.request import Request |
| | | |
| | | return Request.blank('/') |
| | | |
| | | def test_generate_external_url(self): |
| | |
| | | request = self._makeRequest() |
| | | request.registry = self.config.registry |
| | | self.assertEqual( |
| | | request.route_url('acme', foo='bar'), |
| | | 'https://acme.org/path/bar') |
| | | request.route_url('acme', foo='bar'), 'https://acme.org/path/bar' |
| | | ) |
| | | |
| | | def test_generate_external_url_without_scheme(self): |
| | | self.config.add_route('acme', '//acme.org/path/{foo}') |
| | | request = self._makeRequest() |
| | | request.registry = self.config.registry |
| | | self.assertEqual( |
| | | request.route_url('acme', foo='bar'), |
| | | 'http://acme.org/path/bar') |
| | | request.route_url('acme', foo='bar'), 'http://acme.org/path/bar' |
| | | ) |
| | | |
| | | def test_generate_external_url_with_explicit_scheme(self): |
| | | self.config.add_route('acme', '//acme.org/path/{foo}') |
| | |
| | | request.registry = self.config.registry |
| | | self.assertEqual( |
| | | request.route_url('acme', foo='bar', _scheme='https'), |
| | | 'https://acme.org/path/bar') |
| | | 'https://acme.org/path/bar', |
| | | ) |
| | | |
| | | def test_generate_external_url_with_explicit_app_url(self): |
| | | self.config.add_route('acme', 'http://acme.org/path/{foo}') |
| | | request = self._makeRequest() |
| | | request.registry = self.config.registry |
| | | self.assertRaises(ValueError, |
| | | request.route_url, 'acme', foo='bar', _app_url='http://fakeme.com') |
| | | self.assertRaises( |
| | | ValueError, |
| | | request.route_url, |
| | | 'acme', |
| | | foo='bar', |
| | | _app_url='http://fakeme.com', |
| | | ) |
| | | |
| | | def test_generate_external_url_route_path(self): |
| | | self.config.add_route('acme', 'https://acme.org/path/{foo}') |
| | |
| | | def pregenerator(request, elements, kw): |
| | | kw['_query'] = {'q': 'foo'} |
| | | return elements, kw |
| | | self.config.add_route('acme', 'https://acme.org/path/{foo}', |
| | | pregenerator=pregenerator) |
| | | |
| | | self.config.add_route( |
| | | 'acme', 'https://acme.org/path/{foo}', pregenerator=pregenerator |
| | | ) |
| | | request = self._makeRequest() |
| | | request.registry = self.config.registry |
| | | self.assertEqual( |
| | | request.route_url('acme', foo='bar'), |
| | | 'https://acme.org/path/bar?q=foo') |
| | | 'https://acme.org/path/bar?q=foo', |
| | | ) |
| | | |
| | | def test_external_url_with_route_prefix(self): |
| | | def includeme(config): |
| | | config.add_route('acme', '//acme.org/{foo}') |
| | | |
| | | self.config.include(includeme, route_prefix='some_prefix') |
| | | request = self._makeRequest() |
| | | request.registry = self.config.registry |
| | | self.assertEqual( |
| | | request.route_url('acme', foo='bar'), |
| | | 'http://acme.org/bar') |
| | | request.route_url('acme', foo='bar'), 'http://acme.org/bar' |
| | | ) |
| | | |
| | | |
| | | class Test_with_route_prefix(unittest.TestCase): |
| | | |
| | | def setUp(self): |
| | | self.config = testing.setUp() |
| | | |
| | |
| | | |
| | | def _makeRequest(self, route): |
| | | from pyramid.request import Request |
| | | |
| | | return Request.blank(route) |
| | | |
| | | def test_old_route_is_preserved(self): |
| | |
| | | with self.config.route_prefix_context('bar'): |
| | | self.config.add_route('acme', '/foo') |
| | | request = self._makeRequest('/') |
| | | self.assertEqual( |
| | | request.route_url('acme'), |
| | | 'http://localhost/bar/foo', |
| | | ) |
| | | self.assertEqual(request.route_url('acme'), 'http://localhost/bar/foo') |
| | | |
| | | def test_route_does_not_have_prefix(self): |
| | | with self.config.route_prefix_context('bar'): |
| | |
| | | |
| | | self.config.add_route('acme', '/foo') |
| | | request = self._makeRequest('/') |
| | | self.assertEqual( |
| | | request.route_url('acme'), |
| | | 'http://localhost/foo', |
| | | ) |
| | | self.assertEqual(request.route_url('acme'), 'http://localhost/foo') |
| | | |
| | | def test_error_reset_prefix(self): |
| | | self.config.route_prefix = 'old_prefix' |
| | |
| | | |
| | | assert self.config.route_prefix == 'old_prefix' |
| | | |
| | | |
| | | class DummyContext(object): |
| | | def __init__(self, next=None): |
| | | self.next = next |
| | | |
| | | |
| | | |
| | | class DummyRoutesMapper: |
| | | raise_exc = None |
| | | |
| | | def __init__(self, route=None, raise_exc=False): |
| | | self.route = route |
| | | |
| | | def get_route(self, route_name): |
| | | return self.route |
| | | |
| | | |
| | | class DummyRoute: |
| | | pregenerator = None |
| | | name = 'route' |
| | | |
| | | def __init__(self, result='/1/2/3'): |
| | | self.result = result |
| | | |
| | | def generate(self, kw): |
| | | self.kw = kw |
| | | return self.result |
| | | |
| | | |
| | | |
| | | class DummyStaticURLInfo: |
| | | def __init__(self, result): |
| | | self.result = result |
| | |
| | | def generate(self, path, request, **kw): |
| | | self.args = path, request, kw |
| | | return self.result |
| | | |
| | | |
| | | |
| | | def makeabs(*elements): |
| | | if WIN: # pragma: no cover |
| | | if WIN: # pragma: no cover |
| | | return r'c:\\' + os.path.sep.join(elements) |
| | | else: |
| | | return os.path.sep + os.path.sep.join(elements) |