def test__make_request(self, request, tapp):
_app = tapp._application
def revert():
tapp._application = _app
request.addfinalizer(revert)
my_env = mock.Mock(spec=dict)
app = mock.Mock(spec=Application)
tapp._application = app
def new_handle_wsgi(env, start):
assert env is my_env
start("test status", [("my-header", "foo"),
("my-other-header", "baz")])
return ["test1", "test2"]
app.handle_wsgi_request.side_effect = new_handle_wsgi
response = tapp._make_request(my_env)
assert response == {
"body": "test1test2",
"headers": {
"my-header": "foo",
"my-other-header": "baz"
},
"status": "test status"
}
def test_reverse(self, m_from_regex, url_router):
pattern = mock.Mock(spec=Pattern)
m_from_regex.return_value = pattern
my_fn = mock.Mock()
url_router.add_route("test", "/{x}", my_fn)
params = {"x": 1}
url = url_router.reverse("test", params=params)
pattern.reverse.assert_called_once_with(params)
assert url == pattern.reverse(params)
def test__start_response(self, app):
res = mock.Mock(spec=BaseResponse)
res._get_wsgi_status.return_value = "200 Test"
res._get_wsgi_headers.return_value = [("Content-Type", "Test")]
start_response = mock.Mock()
app._start_response(res, start_response)
start_response.assert_called_once_with("200 Test",
[("Content-Type", "Test")])
def test__preprocess(self, app, request):
def revert():
app._middleware_handler = None
request.addfinalizer(revert)
app._middleware_handler = mock.Mock()
request = mock.Mock()
res = app._preprocess(request)
assert res == app._middleware_handler.preprocess(request)
def test_handle_wsgi_request(self, m_send, m_resp, m_handle, m_build, app):
req = mock.Mock(spec=BaseRequest)
start_response = mock.Mock()
resp = mock.Mock(spec=BaseResponse)
resp._get_wsgi_content_iterator.return_value = [1, 2, 3]
m_resp.return_value = resp
m_handle.return_value = ("test", "test")
result = list(app.handle_wsgi_request(req, start_response))
assert result == [1, 2, 3]
for mocked in [m_send, m_resp, m_handle, m_build]:
assert mocked.call_count == 1
def test__get_response_preprocess(self, m_pre, app):
response = mock.Mock()
preresponse = mock.Mock()
m_pre.return_value = preresponse
def handler(req, **kwargs):
return response
request = mock.Mock(spec=BaseRequest)
params = {}
real_response = app._get_response(handler, request, params)
m_pre.assert_called_once_with(request)
assert real_response == preresponse
def test__preprocess_exc(self, m_exc, app, request):
def revert():
app._middleware_handler = None
request.addfinalizer(revert)
app._middleware_handler = mock.Mock()
exc = Exception()
app._middleware_handler.preprocess.side_effect = exc
request = mock.Mock()
res = app._preprocess(request)
m_exc.assert_called_once_with(request, exc)
assert res == m_exc(request, exc)
def test__get_response_ok(self, m_pre, m_post, app):
response = mock.Mock()
m_pre.return_value = None
m_post.return_value = response
def handler(req, **kwargs):
return response
request = mock.Mock(spec=BaseRequest)
params = {}
assert app._get_response(handler, request, params) == response
m_pre.assert_called_once_with(request)
m_post.assert_called_once_with(request, response)
def test_get_handler_and_params_from_url_not_found(self, url_router):
pattern_1 = mock.Mock(spec=Pattern)
pattern_1.match.return_value = (False, None)
pattern_2 = mock.Mock(spec=Pattern)
pattern_2.match.return_value = (False, {"test": 1})
pattern_3 = mock.Mock(spec=Pattern)
pattern_3.match.return_value = (False, {"foo": "bar"})
url_router._patterns = [
("test", pattern_1, "xyz"),
("test2", pattern_2, "blah"),
("test3", pattern_3, "super"),
]
with pytest.raises(HttpNotFound):
url_router.get_handler_and_params_from_url("/")
def test__handle_exception(self, m_get, app, request):
def revert():
app._exception_handler = default_exception_handler
request.addfinalizer(revert)
m_get.return_value = 123
m_exc = mock.Mock()
app._exception_handler = m_exc
req = mock.Mock(spec=BaseRequest)
exc = mock.Mock()
result = app._handle_exception(req, exc)
m_exc.assert_called_once_with(req, exc, 123)
m_get.assert_called_once_with(exc)
assert result == m_exc(req, exc, 123)
def test_build_request_from_env(self, m_head, m_const, m_inst, builder):
env = mock.Mock()
req = builder.build_request_from_env(env)
m_inst.assert_called_once_with(env)
built_req_cls = m_inst(env)
built_req = built_req_cls()
m_const.assert_called_once_with(built_req, env)
m_head.assert_called_once_with(built_req, env)
assert req == built_req
def test__get_handler_and_params_exc(self, m_get, app, request):
m_get.side_effect = HttpNotFound
req = mock.Mock(spec=BaseRequest)
result = app._get_handler_and_params(req)
m_get.assert_called_once_with(req)
assert result == (default_exception_handler, {
"exc": None,
"status": 404
})
def test_get_handler_and_params_from_url(self, url_router):
pattern_1 = mock.Mock(spec=Pattern)
pattern_1.match.return_value = (False, None)
pattern_2 = mock.Mock(spec=Pattern)
pattern_2.match.return_value = (True, {"test": 1})
pattern_3 = mock.Mock(spec=Pattern)
pattern_3.match.return_value = (True, {"foo": "bar"})
url_router._patterns = [
("test", pattern_1, "xyz"),
("test2", pattern_2, "blah"),
("test3", pattern_3, "super"),
]
handler, params = url_router.get_handler_and_params_from_url("/")
assert handler == "blah"
assert params == {"test": 1}
pattern_1.match.assert_called_once_with("/")
pattern_2.match.assert_called_once_with("/")
assert not pattern_3.match.called
def test__get_response_other_error(self, m_handle, app):
exc = Exception()
def handler(req, test):
raise exc
req = mock.Mock(spec=BaseRequest)
params = {"test": 11}
res = app._get_response(handler, req, params)
m_handle.assert_called_once_with(req, exc)
assert res == m_handle(req, exc)
def tparams():
return {
"url": mock.Mock(),
"content_type": mock.Mock(),
"method": mock.Mock(),
"body": mock.Mock(),
"headers": mock.Mock(),
"query_params": mock.Mock(),
"charset": mock.Mock()
}
def test_add_route_exists(self, m_from, url_router):
my_fn = mock.Mock()
my_fn_2 = mock.Mock()
url_router.add_route("test", "/", my_fn)
with pytest.raises(RoutingException):
url_router.add_route("test", "/2", my_fn_2)
def test_add_route(self, m_from, url_router):
my_fn = mock.Mock()
url_router.add_route("test", "/", my_fn)
assert url_router._handlers == {"test": ("test", 1, my_fn)}
def test_get_handler_and_params_from_request(self, m_get, url_router):
req = mock.Mock(spec=BaseRequest)
handle = url_router.get_handler_and_params_from_request(req)
m_get.assert_called_once_with(req.url)
assert handle == m_get(req.url)
def test__get_wsgi_content_iterator(self, frm):
frm.content = mock.Mock()
chunks = list(frm._get_wsgi_content_iterator())
assert chunks == [frm.content]
def test_set_item(self, cid):
value = mock.Mock()
cid["XYZ"] = value
assert cid["xyz"] is value
assert cid["xYz"] is value
def test__get_handler_and_params(self, m_get, app, request):
req = mock.Mock(spec=BaseRequest)
result = app._get_handler_and_params(req)
m_get.assert_called_once_with(req)
assert result == m_get(req)
def test__preprocess_no_middle(self, app, request):
request = mock.Mock()
res = app._preprocess(request)
assert res is None
def test__postprocess_no_middle(self, app, request):
request = mock.Mock()
response = mock.Mock()
res = app._postprocess(request, response)
assert res is response
