def test_add_multiple_routes(self):
route = Router.build_route_regexp(r'/{var1}/{var2}/{var3}')
path = r'/1/12/123'
path_params = Router.match_path(route, path)
self.assertDictEqual(
{'var1': '1', 'var2': '12', 'var3': '123'},
path_params)
def test_route_regexp_multiple_vars(self):
route = Router.build_route_regexp(r'/path/{var1}/edit/{var2}')
path = r'/path/12/edit/name'
path_params = Router.match_path(route, path)
self.assertDictEqual(
{'var1': '12', 'var2': 'name'},
path_params)
def test_add_multiple_routes(self):
route = Router.build_route_regexp(r'/{var1}/{var2}/{var3}')
path = r'/1/12/123'
path_params = Router.match_path(route, path)
self.assertDictEqual({
'var1': '1',
'var2': '12',
'var3': '123'
}, path_params)
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
self.router = Router()
self.server = self.server._replace(router=self.router, loop=self.loop)
self.reader = asyncio.streams.StreamReader(loop=self.loop)
self.writer = MagicMock(spec=asyncio.streams.StreamWriter)
self.writer.write = MagicMock()
self.writer.drain = AsyncMock()
self.writer.close = MagicMock()
self.conn = HTTPConnection(self.server, self.reader, self.writer)
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
self.router = Router()
self.server = self.server._replace(router=self.router, loop=self.loop)
self.reader = asyncio.streams.StreamReader(loop=self.loop)
self.writer = MagicMock(spec=asyncio.streams.StreamWriter)
self.writer.write = MagicMock()
self.writer.drain = AsyncMock()
self.writer.close = MagicMock()
self.conn = HTTPConnection(self.server, self.reader, self.writer)
class TestHTTPConnection(t.TestCase):
@classmethod
def setUpClass(cls):
cls.server = HTTPServerMock(router=None,
http_parser=http_parser,
loop=None)
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
self.router = Router()
self.server = self.server._replace(router=self.router, loop=self.loop)
self.reader = asyncio.streams.StreamReader(loop=self.loop)
self.writer = MagicMock(spec=asyncio.streams.StreamWriter)
self.writer.write = MagicMock()
self.writer.drain = AsyncMock()
self.writer.close = MagicMock()
self.conn = HTTPConnection(self.server, self.reader, self.writer)
def tearDown(self):
self.loop.stop()
self.loop.close()
def test_empty_get_request(self):
mock_get_handler = AsyncMock(return_value='response')
self.reader.feed_data(b'GET / http/1.1\r\n\r\n')
self.router.add_route(r'/', mock_get_handler)
self.loop.run_until_complete(self.conn.handle_request())
self.assertTrue(
self.writer.write.call_args[0][0].endswith(b'response'))
def test_url_params_get_request(self):
mock_get_handler = AsyncMock(return_value='response')
self.reader.feed_data(b'GET /12/edit/bob http/1.1\r\n\r\n')
self.router.add_route(r'/{id}/edit/{name}', mock_get_handler)
self.loop.run_until_complete(self.conn.handle_request())
mock_get_handler.assert_any_call(ANY, id='12', name='bob')
def test_post_request(self):
async def echo_coro(r):
return bytes(r.body_raw).decode('utf-8')
self.reader.feed_data(
(b'POST / http/1.1\r\nContent-Length:8\r\n'
b'Content-Type: application/x-www-form-urlencoded\r\n\r\n'
b'abcd=123'))
self.router.add_route(r'/', echo_coro)
self.loop.run_until_complete(self.conn.handle_request())
self.assertTrue(
self.writer.write.call_args[0][0].endswith(b'abcd=123'))
def test_post_large_request(self):
async def echo_coro(r):
return bytes(r.body_raw).decode('utf-8')
self.reader.feed_data(
(b'POST / http/1.1\r\nContent-Length: 2000\r\n'
b'Content-Type: application/x-www-form-urlencoded\r\n\r\n') +
b'abcd=12345' * 200)
self.router.add_route(r'/', echo_coro)
self.loop.run_until_complete(self.conn.handle_request())
rsp_body = self.writer.write.call_args[0][0].split(b'\r\n\r\n')[1]
self.assertEqual(len(rsp_body), 2000)
@t.skip('')
def test_request_timeout(self):
self.reader.feed_data(b'GET / ')
self.loop.run_until_complete(self.conn.handle_request())
async def home(r):
rsp = Response()
rsp.set_header('Content-Type', 'text/html')
rsp.body = '<html><body><b>test</b></body></html>'
return rsp
# get route + params
async def welcome(r, name):
return "Welcome {}".format(name)
# post route + body param
async def parse_form(r):
if r.method == 'GET':
return 'form'
else:
name = r.body.get('name', '')[0]
password = r.body.get('password', '')[0]
return "{0}:{1}".format(name, password)
## application = router + http server
router = Router()
router.add_routes({
r'/welcome/{name}': welcome,
r'/': home,
r'/login': parse_form,})
app = App(router)
app.start_server()
def setUp(self):
self.router = Router()
self.handler = lambda r, *args: (
r,
args,
)
class TestRouter(t.TestCase):
def setUp(self):
self.router = Router()
self.handler = lambda r, *args: (
r,
args,
)
def test_unique_route(self):
route = r'/path'
route2 = r'/path'
self.router.add_route(route, self.handler)
with self.assertRaises(DuplicateRoute):
self.router.add_route(route2, self.handler)
def test_transform_route_into_regexp(self):
route = r'/path/{id}'
expected_regexp_str = r'^/path/(?P<id>[a-zA-Z0-9_-]+)$'
regexp_obj = self.router.build_route_regexp(route)
self.assertEqual(expected_regexp_str, regexp_obj.pattern)
def test_route_regexp_no_vars(self):
route = Router.build_route_regexp(r'/path')
path = r'/path'
path_params = Router.match_path(route, path)
self.assertDictEqual(path_params, {})
def test_route_regexp_one_var(self):
route = Router.build_route_regexp(r'/path/{var1}')
path = r'/path/12'
path_params = Router.match_path(route, path)
self.assertDictEqual({'var1': '12'}, path_params)
def test_route_regexp_multiple_vars(self):
route = Router.build_route_regexp(r'/path/{var1}/edit/{var2}')
path = r'/path/12/edit/name'
path_params = Router.match_path(route, path)
self.assertDictEqual({'var1': '12', 'var2': 'name'}, path_params)
def test_add_multiple_routes(self):
route = Router.build_route_regexp(r'/{var1}/{var2}/{var3}')
path = r'/1/12/123'
path_params = Router.match_path(route, path)
self.assertDictEqual({
'var1': '1',
'var2': '12',
'var3': '123'
}, path_params)
def test_raise_404(self):
with self.assertRaises(NotFoundException):
self.router.get_handler('/some-path')
def test_inject_request_into_handler(self):
route = r'/path'
self.router.add_route(route, self.handler)
wrapped_handler = self.router.get_handler(route)
response = yield from wrapped_handler.handle('request')
self.assertEqual(response, 'Body!')
def test_update_request_path_params(self):
class DummyRequest:
def __init__(self):
self.path_params = {}
request = DummyRequest()
route = r'/path/{id}'
path = r'/path/12'
self.router.add_route(route, self.handler)
wrapped_handler = self.router.get_handler(path)
response = yield from wrapped_handler.handle(request)
self.assertTupleEqual((request, ['12']), response)
def test_route_precedence_matching(self):
route1 = r'/'
route2 = r'/welcome/{name}'
path = '/welcome/bob'
handler2 = lambda r, name: name
self.router.add_routes({route1: self.handler, route2: handler2})
wrapped_handler = self.router.get_handler(path)
response = yield from wrapped_handler.handle('request')
self.assertEqual(response, 'bob')
def test_route_regexp_multiple_vars(self):
route = Router.build_route_regexp(r'/path/{var1}/edit/{var2}')
path = r'/path/12/edit/name'
path_params = Router.match_path(route, path)
self.assertDictEqual({'var1': '12', 'var2': 'name'}, path_params)
def test_route_regexp_one_var(self):
route = Router.build_route_regexp(r'/path/{var1}')
path = r'/path/12'
path_params = Router.match_path(route, path)
self.assertDictEqual({'var1': '12'}, path_params)
def test_route_regexp_no_vars(self):
route = Router.build_route_regexp(r'/path')
path = r'/path'
path_params = Router.match_path(route, path)
self.assertDictEqual(path_params, {})
class TestHTTPConnection(t.TestCase):
@classmethod
def setUpClass(cls):
cls.server = HTTPServerMock(router=None,
http_parser=http_parser,
loop=None)
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
self.router = Router()
self.server = self.server._replace(router=self.router, loop=self.loop)
self.reader = asyncio.streams.StreamReader(loop=self.loop)
self.writer = MagicMock(spec=asyncio.streams.StreamWriter)
self.writer.write = MagicMock()
self.writer.drain = AsyncMock()
self.writer.close = MagicMock()
self.conn = HTTPConnection(self.server, self.reader, self.writer)
def tearDown(self):
self.loop.stop()
self.loop.close()
def test_empty_get_request(self):
mock_get_handler = AsyncMock(return_value='response')
self.reader.feed_data(b'GET / http/1.1\r\n\r\n')
self.router.add_route(r'/', mock_get_handler)
self.loop.run_until_complete(self.conn.handle_request())
self.assertTrue(self.writer.write.call_args[0][0].endswith(b'response'))
def test_url_params_get_request(self):
mock_get_handler = AsyncMock(return_value='response')
self.reader.feed_data(b'GET /12/edit/bob http/1.1\r\n\r\n')
self.router.add_route(r'/{id}/edit/{name}', mock_get_handler)
self.loop.run_until_complete(self.conn.handle_request())
mock_get_handler.assert_any_call(ANY, id='12', name='bob')
def test_post_request(self):
async def echo_coro(r):
return bytes(r.body_raw).decode('utf-8')
self.reader.feed_data(
(b'POST / http/1.1\r\nContent-Length:8\r\n'
b'Content-Type: application/x-www-form-urlencoded\r\n\r\n'
b'abcd=123'))
self.router.add_route(r'/', echo_coro)
self.loop.run_until_complete(self.conn.handle_request())
self.assertTrue(self.writer.write.call_args[0][0].endswith(b'abcd=123'))
def test_post_large_request(self):
async def echo_coro(r):
return bytes(r.body_raw).decode('utf-8')
self.reader.feed_data(
(b'POST / http/1.1\r\nContent-Length: 2000\r\n'
b'Content-Type: application/x-www-form-urlencoded\r\n\r\n') +
b'abcd=12345' * 200)
self.router.add_route(r'/', echo_coro)
self.loop.run_until_complete(self.conn.handle_request())
rsp_body = self.writer.write.call_args[0][0].split(b'\r\n\r\n')[1]
self.assertEqual(len(rsp_body), 2000)
@t.skip('')
def test_request_timeout(self):
self.reader.feed_data(b'GET / ')
self.loop.run_until_complete(self.conn.handle_request())
def setUp(self):
self.router = Router()
self.handler = lambda r, *args: (r, args,)
class TestRouter(t.TestCase):
def setUp(self):
self.router = Router()
self.handler = lambda r, *args: (r, args,)
def test_unique_route(self):
route = r'/path'
route2 = r'/path'
self.router.add_route(route, self.handler)
with self.assertRaises(DuplicateRoute):
self.router.add_route(route2, self.handler)
def test_transform_route_into_regexp(self):
route = r'/path/{id}'
expected_regexp_str = r'^/path/(?P<id>[a-zA-Z0-9_-]+)$'
regexp_obj = self.router.build_route_regexp(route)
self.assertEqual(expected_regexp_str, regexp_obj.pattern)
def test_route_regexp_no_vars(self):
route = Router.build_route_regexp(r'/path')
path = r'/path'
path_params = Router.match_path(route, path)
self.assertDictEqual(path_params, {})
def test_route_regexp_one_var(self):
route = Router.build_route_regexp(r'/path/{var1}')
path = r'/path/12'
path_params = Router.match_path(route, path)
self.assertDictEqual({'var1': '12'}, path_params)
def test_route_regexp_multiple_vars(self):
route = Router.build_route_regexp(r'/path/{var1}/edit/{var2}')
path = r'/path/12/edit/name'
path_params = Router.match_path(route, path)
self.assertDictEqual(
{'var1': '12', 'var2': 'name'},
path_params)
def test_add_multiple_routes(self):
route = Router.build_route_regexp(r'/{var1}/{var2}/{var3}')
path = r'/1/12/123'
path_params = Router.match_path(route, path)
self.assertDictEqual(
{'var1': '1', 'var2': '12', 'var3': '123'},
path_params)
def test_raise_404(self):
with self.assertRaises(NotFoundException):
self.router.get_handler('/some-path')
def test_inject_request_into_handler(self):
route = r'/path'
self.router.add_route(route, self.handler)
wrapped_handler = self.router.get_handler(route)
response = yield from wrapped_handler.handle('request')
self.assertEqual(response, 'Body!')
def test_update_request_path_params(self):
class DummyRequest:
def __init__(self):
self.path_params = {}
request = DummyRequest()
route = r'/path/{id}'
path = r'/path/12'
self.router.add_route(route, self.handler)
wrapped_handler = self.router.get_handler(path)
response = yield from wrapped_handler.handle(request)
self.assertTupleEqual(
(request, ['12']),
response)
def test_route_precedence_matching(self):
route1 = r'/'
route2 = r'/welcome/{name}'
path = '/welcome/bob'
handler2 = lambda r, name: name
self.router.add_routes({route1: self.handler, route2: handler2})
wrapped_handler = self.router.get_handler(path)
response = yield from wrapped_handler.handle('request')
self.assertEqual(response, 'bob')
def test_route_regexp_one_var(self):
route = Router.build_route_regexp(r'/path/{var1}')
path = r'/path/12'
path_params = Router.match_path(route, path)
self.assertDictEqual({'var1': '12'}, path_params)
# GET simple route
async def home(r):
rsp = Response()
rsp.set_header('Content-Type','text/html')
rsp.body = '<html><body><b>test</b></body></html>'
return rsp
# GET route + params
async def welcome(r, name):
return "Welcome {}".format(name)
# POST route + body param
async def parse_form(r):
if r.method == 'GET':
return 'form'
else:
name = r.body.get('name','')[0]
password = r.body.get('password','')[0]
return "{0}:{1}".format(name,password)
# application = router + http server
router = Router()
router.add_routes({
r'/welome/{name}':welcome,
r'/':home,
r'/login': parse_form,})
app = App(router)
app.start_server()
})
def test_route_regexp_no_vars(self):
route = Router.build_route_regexp(r'/path')
path = r'/path'
path_params = Router.match_path(route, path)
self.assertDictEqual(path_params, {})