def test_rule_unhashable():
rule = r.Rule('/foo', {'meh': 'muh'}, 'x', ['POST'], False, 'x', True,
None)
pytest.raises(TypeError, hash, rule)
def test_uuid_converter(self):
m = r.Map([r.Rule('/a/<uuid:a_uuid>', endpoint='a')])
a = m.bind('example.org', '/')
rooute, kwargs = a.match('/a/a8098c1a-f86e-11da-bd1a-00112444be1e')
assert type(kwargs['a_uuid']) == uuid.UUID
def test_path():
map = r.Map([
r.Rule('/', defaults={'name': 'FrontPage'}, endpoint='page'),
r.Rule('/Special', endpoint='special'),
r.Rule('/<int:year>', endpoint='year'),
r.Rule('/<path:name>:foo', endpoint='foopage'),
r.Rule('/<path:name>:<path:name2>', endpoint='twopage'),
r.Rule('/<path:name>', endpoint='page'),
r.Rule('/<path:name>/edit', endpoint='editpage'),
r.Rule('/<path:name>/silly/<path:name2>', endpoint='sillypage'),
r.Rule('/<path:name>/silly/<path:name2>/edit',
endpoint='editsillypage'),
r.Rule('/Talk:<path:name>', endpoint='talk'),
r.Rule('/User:<username>', endpoint='user'),
r.Rule('/User:<username>/<path:name>', endpoint='userpage'),
r.Rule('/User:<username>/comment/<int:id>-<int:replyId>',
endpoint='usercomment'),
r.Rule('/Files/<path:file>', endpoint='files'),
r.Rule('/<admin>/<manage>/<things>', endpoint='admin'),
])
adapter = map.bind('example.org', '/')
assert adapter.match('/') == ('page', {'name': 'FrontPage'})
pytest.raises(r.RequestRedirect, lambda: adapter.match('/FrontPage'))
assert adapter.match('/Special') == ('special', {})
assert adapter.match('/2007') == ('year', {'year': 2007})
assert adapter.match('/Some:foo') == ('foopage', {'name': 'Some'})
assert adapter.match('/Some:bar') == ('twopage', {
'name': 'Some',
'name2': 'bar'
})
assert adapter.match('/Some/Page') == ('page', {'name': 'Some/Page'})
assert adapter.match('/Some/Page/edit') == ('editpage', {
'name': 'Some/Page'
})
assert adapter.match('/Foo/silly/bar') == ('sillypage', {
'name': 'Foo',
'name2': 'bar'
})
assert adapter.match('/Foo/silly/bar/edit') == ('editsillypage', {
'name': 'Foo',
'name2': 'bar'
})
assert adapter.match('/Talk:Foo/Bar') == ('talk', {'name': 'Foo/Bar'})
assert adapter.match('/User:thomas') == ('user', {'username': '******'})
assert adapter.match('/User:thomas/projects/werkzeug') == \
('userpage', {'username': '******', 'name': 'projects/werkzeug'})
assert adapter.match('/User:thomas/comment/123-456') == \
('usercomment', {'username': '******', 'id': 123, 'replyId': 456})
assert adapter.match('/Files/downloads/werkzeug/0.2.zip') == \
('files', {'file': 'downloads/werkzeug/0.2.zip'})
assert adapter.match('/Jerry/eats/cheese') == \
('admin', {'admin': 'Jerry', 'manage': 'eats', 'things': 'cheese'})
def Rule(path, handler, *args):
return routing.Rule(path, endpoint=(handler, args))
def test_non_string_parts(self):
m = r.Map([r.Rule('/<foo>', endpoint='foo')])
a = m.bind('example.com')
self.assert_equal(a.build('foo', {'foo': 42}), '/42')
def test_external_building_with_port():
map = r.Map([r.Rule("/", endpoint="index")])
adapter = map.bind("example.org:5000", "/")
built_url = adapter.build("index", {}, force_external=True)
assert built_url == "http://example.org:5000/", built_url
def RegisterHttpRouteHandler(method, route, renderer_cls):
"""Registers given ApiCallRenderer for given method and route."""
HTTP_ROUTING_MAP.add(routing.Rule(
route, methods=[method],
endpoint=renderer_cls))
def test_build_url_with_arg_keyword():
map = r.Map([r.Rule("/foo/<string:class>", endpoint="foo")])
adapter = map.bind("example.org", "/", subdomain="blah")
ret = adapter.build("foo", {"class": "bar"})
assert ret == "http://example.org/foo/bar"
def test_path():
map = r.Map([
r.Rule("/", defaults={"name": "FrontPage"}, endpoint="page"),
r.Rule("/Special", endpoint="special"),
r.Rule("/<int:year>", endpoint="year"),
r.Rule("/<path:name>:foo", endpoint="foopage"),
r.Rule("/<path:name>:<path:name2>", endpoint="twopage"),
r.Rule("/<path:name>", endpoint="page"),
r.Rule("/<path:name>/edit", endpoint="editpage"),
r.Rule("/<path:name>/silly/<path:name2>", endpoint="sillypage"),
r.Rule("/<path:name>/silly/<path:name2>/edit",
endpoint="editsillypage"),
r.Rule("/Talk:<path:name>", endpoint="talk"),
r.Rule("/User:<username>", endpoint="user"),
r.Rule("/User:<username>/<path:name>", endpoint="userpage"),
r.Rule(
"/User:<username>/comment/<int:id>-<int:replyId>",
endpoint="usercomment",
),
r.Rule("/Files/<path:file>", endpoint="files"),
r.Rule("/<admin>/<manage>/<things>", endpoint="admin"),
])
adapter = map.bind("example.org", "/")
assert adapter.match("/") == ("page", {"name": "FrontPage"})
pytest.raises(r.RequestRedirect, lambda: adapter.match("/FrontPage"))
assert adapter.match("/Special") == ("special", {})
assert adapter.match("/2007") == ("year", {"year": 2007})
assert adapter.match("/Some:foo") == ("foopage", {"name": "Some"})
assert adapter.match("/Some:bar") == ("twopage", {
"name": "Some",
"name2": "bar"
})
assert adapter.match("/Some/Page") == ("page", {"name": "Some/Page"})
assert adapter.match("/Some/Page/edit") == ("editpage", {
"name": "Some/Page"
})
assert adapter.match("/Foo/silly/bar") == (
"sillypage",
{
"name": "Foo",
"name2": "bar"
},
)
assert adapter.match("/Foo/silly/bar/edit") == (
"editsillypage",
{
"name": "Foo",
"name2": "bar"
},
)
assert adapter.match("/Talk:Foo/Bar") == ("talk", {"name": "Foo/Bar"})
assert adapter.match("/User:thomas") == ("user", {"username": "******"})
assert adapter.match("/User:thomas/projects/werkzeug") == (
"userpage",
{
"username": "******",
"name": "projects/werkzeug"
},
)
assert adapter.match("/User:thomas/comment/123-456") == (
"usercomment",
{
"username": "******",
"id": 123,
"replyId": 456
},
)
assert adapter.match("/Files/downloads/werkzeug/0.2.zip") == (
"files",
{
"file": "downloads/werkzeug/0.2.zip"
},
)
assert adapter.match("/Jerry/eats/cheese") == (
"admin",
{
"admin": "Jerry",
"manage": "eats",
"things": "cheese"
},
)
def test_allowed_methods_querying():
m = r.Map([r.Rule('/<foo>', methods=['GET', 'HEAD']),
r.Rule('/foo', methods=['POST'])])
a = m.bind('example.org')
assert sorted(a.allowed_methods('/foo')) == ['GET', 'HEAD', 'POST']
def test_both_bind_and_match_path_info_are_none():
m = r.Map([r.Rule(u"/", endpoint="index")])
ma = m.bind("example.org")
strict_eq(ma.match(), ("index", {}))
def test_non_string_parts():
m = r.Map([
r.Rule('/<foo>', endpoint='foo')
])
a = m.bind('example.com')
assert a.build('foo', {'foo': 42}) == '/42'
def test_adapter_url_parameter_sorting():
map = r.Map([r.Rule('/', endpoint='index')], sort_parameters=True,
sort_key=lambda x: x[1])
adapter = map.bind('localhost', '/')
assert adapter.build('index', {'x': 20, 'y': 10, 'z': 30},
force_external=True) == 'http://localhost/?y=10&x=20&z=30'
def test_pass_str_as_router_methods():
with pytest.raises(TypeError):
r.Rule('/get', methods='GET')
def test_pass_str_as_router_methods():
with pytest.raises(TypeError):
r.Rule("/get", methods="GET")
def test_server_name_match_default_port(base, name):
environ = create_environ("/foo", base_url=base)
map = r.Map([r.Rule("/foo", endpoint="foo")])
adapter = map.bind_to_environ(environ, server_name=name)
assert adapter.match() == ("foo", {})
def test_protocol_joining_bug():
m = r.Map([r.Rule("/<foo>", endpoint="x")])
a = m.bind("example.org")
assert a.build("x", {"foo": "x:y"}) == "/x:y"
assert a.build("x", {"foo": "x:y"},
force_external=True) == "http://example.org/x:y"
def test_adapter_match_return_rule():
rule = r.Rule("/foo/", endpoint="foo")
map = r.Map([rule])
adapter = map.bind("localhost", "/")
assert adapter.match("/foo/", return_rule=True) == (rule, {})
def test_external_building_with_port_bind_to_environ_wrong_servername():
map = r.Map([r.Rule("/", endpoint="index")])
environ = create_environ("/", "http://example.org:5000/")
adapter = map.bind_to_environ(environ, server_name="example.org")
assert adapter.subdomain == "<invalid>"
def test_rule_unhashable():
rule = r.Rule("/foo", {"meh": "muh"}, "x", ["POST"], False, "x", True,
None)
pytest.raises(TypeError, hash, rule)
class HttpConnector(connector.Connector):
"""API connector implementation that works through HTTP API."""
class ResponseFormat(object):
JSON = 0
TYPED_JSON = 1
HANDLERS_MAP = routing.Map([
routing.Rule("/api/clients", methods=["GET"],
endpoint="SearchClients"),
routing.Rule("/api/clients/<client_id>",
methods=["GET"],
endpoint="GetClient"),
routing.Rule("/api/clients/<client_id>/flows",
methods=["GET"],
endpoint="ListFlows"),
routing.Rule("/api/clients/<client_id>/flows",
methods=["POST"],
endpoint="CreateFlow"),
])
JSON_PREFIX = ")]}\'\n"
DEFAULT_PAGE_SIZE = 50
def __init__(self,
api_endpoint=None,
auth=None,
response_format=ResponseFormat.JSON,
page_size=None):
super(HttpConnector, self).__init__()
self.api_endpoint = api_endpoint
self.auth = auth
self.response_format = response_format
self.page_size = page_size or self.DEFAULT_PAGE_SIZE
self.csrf_token = None
parsed_url = urlparse.urlparse(api_endpoint)
self.urls = self.HANDLERS_MAP.bind(parsed_url.netloc, "/")
def _GetCSRFToken(self):
logger.debug("Fetching CSRF token from %s...", self.api_endpoint)
index_response = requests.get(self.api_endpoint, auth=self.auth)
csrf_token = index_response.cookies.get("csrftoken")
if not csrf_token:
raise RuntimeError("Can't get CSRF token.")
logger.debug("Got CSRF token: %s", csrf_token)
return csrf_token
def _GetMethodUrlAndQueryParams(self, handler_name, args):
path_params = {}
query_params = {}
for field, value in args.ListFields():
if self.HANDLERS_MAP.is_endpoint_expecting(handler_name,
field.name):
path_params[field.name] = value
else:
query_params[field.name] = value
url = self.urls.build(handler_name, path_params, force_external=True)
method = None
for rule in self.HANDLERS_MAP.iter_rules():
if rule.endpoint == handler_name:
method = [m for m in rule.methods if m != "HEAD"][0]
if not method:
raise RuntimeError("Can't find method for %s" % handler_name)
return method, url, query_params
def _QueryParamsToBody(self, query_params):
result = {}
for k, v in query_params.items():
result[k] = self._ToJSON(v)
return result
def _ToJSON(self, value):
if isinstance(value, semantic_pb2.AnyValue):
proto = utils.TypeUrlToMessage(value.type_url)
proto.ParseFromString(value.value)
return self._ToJSON(proto)
elif isinstance(value, message.Message):
result = {}
for descriptor, value in value.ListFields():
result[descriptor.name] = self._ToJSON(value)
return result
else:
return value
def SendRequest(self, handler_name, args):
if not self.csrf_token:
self.csrf_token = self._GetCSRFToken()
headers = {
"x-csrftoken": self.csrf_token,
"x-requested-with": "XMLHttpRequest"
}
cookies = {"csrftoken": self.csrf_token}
method, url, query_params = self._GetMethodUrlAndQueryParams(
handler_name, args)
body = None
if method != "GET":
body = self._QueryParamsToBody(query_params)
query_params = {}
if self.response_format == self.ResponseFormat.JSON:
query_params["strip_type_info"] = "1"
logger.debug("%s request: %s (query: %s, body: %s, headers %s)",
method, url, query_params, body, headers)
request = requests.Request(method,
url,
json=body,
params=query_params,
headers=headers,
cookies=cookies)
prepped_request = request.prepare()
session = requests.Session()
response = session.send(prepped_request)
content = response.content
logger.debug("%s response (%s, %d):\n%s", method, url,
response.status_code, content)
if content[:len(self.JSON_PREFIX)] != self.JSON_PREFIX:
raise RuntimeError("JSON prefix %s is not in response:\n%s" %
(self.JSON_PREFIX, content))
json_str = content[len(self.JSON_PREFIX):]
parsed_json = json.loads(json_str)
if response.status_code == 200:
return parsed_json
else:
raise RuntimeError("Server error: " + parsed_json["message"])
def SendIteratorRequest(self, handler_name, args):
response = self.SendRequest(handler_name, args)
total_count = None
try:
total_count = response["total_count"]
except KeyError:
pass
return utils.ItemsIterator(items=response["items"],
total_count=total_count)
def GetDataAttribute(self, data, attribute_name):
if self.response_format == self.ResponseFormat.JSON:
return data[attribute_name]
elif self.response_format == self.ResponseFormat.TYPED_JSON:
return data[attribute_name]["value"]
else:
raise RuntimeError("Unexpected response_format: %d",
self.response_format)
def test_rule_templates():
testcase = r.RuleTemplate([
r.Submount(
"/test/$app",
[
r.Rule("/foo/", endpoint="handle_foo"),
r.Rule("/bar/", endpoint="handle_bar"),
r.Rule("/baz/", endpoint="handle_baz"),
],
),
r.EndpointPrefix(
"${app}",
[
r.Rule("/${app}-blah", endpoint="bar"),
r.Rule("/${app}-meh", endpoint="baz"),
],
),
r.Subdomain(
"$app",
[
r.Rule("/blah", endpoint="x_bar"),
r.Rule("/meh", endpoint="x_baz")
],
),
])
url_map = r.Map([
testcase(app="test1"),
testcase(app="test2"),
testcase(app="test3"),
testcase(app="test4"),
])
out = sorted([(x.rule, x.subdomain, x.endpoint)
for x in url_map.iter_rules()])
assert out == [
("/blah", "test1", "x_bar"),
("/blah", "test2", "x_bar"),
("/blah", "test3", "x_bar"),
("/blah", "test4", "x_bar"),
("/meh", "test1", "x_baz"),
("/meh", "test2", "x_baz"),
("/meh", "test3", "x_baz"),
("/meh", "test4", "x_baz"),
("/test/test1/bar/", "", "handle_bar"),
("/test/test1/baz/", "", "handle_baz"),
("/test/test1/foo/", "", "handle_foo"),
("/test/test2/bar/", "", "handle_bar"),
("/test/test2/baz/", "", "handle_baz"),
("/test/test2/foo/", "", "handle_foo"),
("/test/test3/bar/", "", "handle_bar"),
("/test/test3/baz/", "", "handle_baz"),
("/test/test3/foo/", "", "handle_foo"),
("/test/test4/bar/", "", "handle_bar"),
("/test/test4/baz/", "", "handle_baz"),
("/test/test4/foo/", "", "handle_foo"),
("/test1-blah", "", "test1bar"),
("/test1-meh", "", "test1baz"),
("/test2-blah", "", "test2bar"),
("/test2-meh", "", "test2baz"),
("/test3-blah", "", "test3bar"),
("/test3-meh", "", "test3baz"),
("/test4-blah", "", "test4bar"),
("/test4-meh", "", "test4baz"),
]
def test_path(self):
map = r.Map([
r.Rule('/', defaults={'name': 'FrontPage'}, endpoint='page'),
r.Rule('/Special', endpoint='special'),
r.Rule('/<int:year>', endpoint='year'),
r.Rule('/<path:name>', endpoint='page'),
r.Rule('/<path:name>/edit', endpoint='editpage'),
r.Rule('/<path:name>/silly/<path:name2>', endpoint='sillypage'),
r.Rule('/<path:name>/silly/<path:name2>/edit',
endpoint='editsillypage'),
r.Rule('/Talk:<path:name>', endpoint='talk'),
r.Rule('/User:<username>', endpoint='user'),
r.Rule('/User:<username>/<path:name>', endpoint='userpage'),
r.Rule('/Files/<path:file>', endpoint='files'),
])
adapter = map.bind('example.org', '/')
assert adapter.match('/') == ('page', {'name': 'FrontPage'})
self.assert_raises(r.RequestRedirect,
lambda: adapter.match('/FrontPage'))
assert adapter.match('/Special') == ('special', {})
assert adapter.match('/2007') == ('year', {'year': 2007})
assert adapter.match('/Some/Page') == ('page', {'name': 'Some/Page'})
assert adapter.match('/Some/Page/edit') == ('editpage', {
'name': 'Some/Page'
})
assert adapter.match('/Foo/silly/bar') == ('sillypage', {
'name': 'Foo',
'name2': 'bar'
})
assert adapter.match('/Foo/silly/bar/edit') == ('editsillypage', {
'name': 'Foo',
'name2': 'bar'
})
assert adapter.match('/Talk:Foo/Bar') == ('talk', {'name': 'Foo/Bar'})
assert adapter.match('/User:thomas') == ('user', {
'username': '******'
})
assert adapter.match('/User:thomas/projects/werkzeug') == \
('userpage', {'username':'******', 'name':'projects/werkzeug'})
assert adapter.match('/Files/downloads/werkzeug/0.2.zip') == \
('files', {'file':'downloads/werkzeug/0.2.zip'})
def test_non_string_parts():
m = r.Map([r.Rule("/<foo>", endpoint="foo")])
a = m.bind("example.com")
assert a.build("foo", {"foo": 42}) == "/42"
def test_complex_routing_rules(self):
m = r.Map([
r.Rule('/', endpoint='index'),
r.Rule('/<int:blub>', endpoint='an_int'),
r.Rule('/<blub>', endpoint='a_string'),
r.Rule('/foo/', endpoint='nested'),
r.Rule('/foobar/', endpoint='nestedbar'),
r.Rule('/foo/<path:testing>/', endpoint='nested_show'),
r.Rule('/foo/<path:testing>/edit', endpoint='nested_edit'),
r.Rule('/users/', endpoint='users', defaults={'page': 1}),
r.Rule('/users/page/<int:page>', endpoint='users'),
r.Rule('/foox', endpoint='foox'),
r.Rule('/<path:bar>/<path:blub>', endpoint='barx_path_path')
])
a = m.bind('example.com')
assert a.match('/') == ('index', {})
assert a.match('/42') == ('an_int', {'blub': 42})
assert a.match('/blub') == ('a_string', {'blub': 'blub'})
assert a.match('/foo/') == ('nested', {})
assert a.match('/foobar/') == ('nestedbar', {})
assert a.match('/foo/1/2/3/') == ('nested_show', {'testing': '1/2/3'})
assert a.match('/foo/1/2/3/edit') == ('nested_edit', {
'testing': '1/2/3'
})
assert a.match('/users/') == ('users', {'page': 1})
assert a.match('/users/page/2') == ('users', {'page': 2})
assert a.match('/foox') == ('foox', {})
assert a.match('/1/2/3') == ('barx_path_path', {
'bar': '1',
'blub': '2/3'
})
assert a.build('index') == '/'
assert a.build('an_int', {'blub': 42}) == '/42'
assert a.build('a_string', {'blub': 'test'}) == '/test'
assert a.build('nested') == '/foo/'
assert a.build('nestedbar') == '/foobar/'
assert a.build('nested_show', {'testing': '1/2/3'}) == '/foo/1/2/3/'
assert a.build('nested_edit',
{'testing': '1/2/3'}) == '/foo/1/2/3/edit'
assert a.build('users', {'page': 1}) == '/users/'
assert a.build('users', {'page': 2}) == '/users/page/2'
assert a.build('foox') == '/foox'
assert a.build('barx_path_path', {
'bar': '1',
'blub': '2/3'
}) == '/1/2/3'
def test_complex_routing_rules():
m = r.Map([
r.Rule("/", endpoint="index"),
r.Rule("/<int:blub>", endpoint="an_int"),
r.Rule("/<blub>", endpoint="a_string"),
r.Rule("/foo/", endpoint="nested"),
r.Rule("/foobar/", endpoint="nestedbar"),
r.Rule("/foo/<path:testing>/", endpoint="nested_show"),
r.Rule("/foo/<path:testing>/edit", endpoint="nested_edit"),
r.Rule("/users/", endpoint="users", defaults={"page": 1}),
r.Rule("/users/page/<int:page>", endpoint="users"),
r.Rule("/foox", endpoint="foox"),
r.Rule("/<path:bar>/<path:blub>", endpoint="barx_path_path"),
])
a = m.bind("example.com")
assert a.match("/") == ("index", {})
assert a.match("/42") == ("an_int", {"blub": 42})
assert a.match("/blub") == ("a_string", {"blub": "blub"})
assert a.match("/foo/") == ("nested", {})
assert a.match("/foobar/") == ("nestedbar", {})
assert a.match("/foo/1/2/3/") == ("nested_show", {"testing": "1/2/3"})
assert a.match("/foo/1/2/3/edit") == ("nested_edit", {"testing": "1/2/3"})
assert a.match("/users/") == ("users", {"page": 1})
assert a.match("/users/page/2") == ("users", {"page": 2})
assert a.match("/foox") == ("foox", {})
assert a.match("/1/2/3") == ("barx_path_path", {"bar": "1", "blub": "2/3"})
assert a.build("index") == "/"
assert a.build("an_int", {"blub": 42}) == "/42"
assert a.build("a_string", {"blub": "test"}) == "/test"
assert a.build("nested") == "/foo/"
assert a.build("nestedbar") == "/foobar/"
assert a.build("nested_show", {"testing": "1/2/3"}) == "/foo/1/2/3/"
assert a.build("nested_edit", {"testing": "1/2/3"}) == "/foo/1/2/3/edit"
assert a.build("users", {"page": 1}) == "/users/"
assert a.build("users", {"page": 2}) == "/users/page/2"
assert a.build("foox") == "/foox"
assert a.build("barx_path_path", {"bar": "1", "blub": "2/3"}) == "/1/2/3"
def test_protocol_joining_bug(self):
m = r.Map([r.Rule('/<foo>', endpoint='x')])
a = m.bind('example.org')
assert a.build('x', {'foo': 'x:y'}) == '/x:y'
assert a.build('x', {'foo': 'x:y'}, force_external=True) == \
'http://example.org/x:y'
def test_uuid_converter():
m = r.Map([r.Rule("/a/<uuid:a_uuid>", endpoint="a")])
a = m.bind("example.org", "/")
rooute, kwargs = a.match("/a/a8098c1a-f86e-11da-bd1a-00112444be1e")
assert type(kwargs["a_uuid"]) == uuid.UUID
def test_adapter_match_return_rule():
rule = r.Rule('/foo/', endpoint='foo')
map = r.Map([rule])
adapter = map.bind('localhost', '/')
assert adapter.match('/foo/', return_rule=True) == (rule, {})
def test_both_bind_and_match_path_info_are_none():
m = r.Map([r.Rule(u'/', endpoint='index')])
ma = m.bind('example.org')
strict_eq(ma.match(), ('index', {}))
