def test_empty_handler_signature(
mocker: ptm.MockFixture,
caplog: logging.LogCaptureFixture,
) -> None:
async def foo() -> pipeline.Response:
...
handler._resolve(
handler=foo,
operation=list(
parser._resolve_operations(
components={},
paths={
'/{name}': {
'post': {
'operationId': 'TestAnalysisNoParameters',
'responses': {
'default': {
'description': 'fake',
},
},
},
},
},
), )[0],
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert 'TestAnalysisNoParameters does not declare any parameters' in caplog.messages
def test_headers_cookies_any(
caplog: logging.LogCaptureFixture,
mocker: ptm.MockFixture,
) -> None:
class R(te.TypedDict):
headers: t.Any
cookies: t.Any
return_code: int
async def test() -> R:
...
handler._resolve(
handler=test,
operation=_make_operation({
'204': {
'description': 'Incorrect return type',
},
}),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
for msg in (
'Detected usage of "return.headers" declared as typing.Any.',
'Detected usage of "return.cookies" declared as typing.Any.',
):
assert any(
filter(lambda m: t.cast(str, m).startswith(msg), caplog.messages))
def test_incorrect_return_http_code(
return_code: t.Type[t.Any],
mocker: ptm.MockFixture,
) -> None:
test_returns = te.TypedDict( # type: ignore
f'ReturnWithCodeAs_{return_code}',
{'http_code': return_code},
)
async def test() -> test_returns:
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
handler=test,
operation=_make_operation({
'204': {
'description': 'Incorrect return type',
},
}),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert err
assert err.value
assert 1 == len(err.value)
def test_incorrect_return_type(
return_type: t.Type[t.Any],
mocker: ptm.MockFixture,
) -> None:
async def test() -> return_type: # type: ignore
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
handler=test,
operation=_make_operation({
'204': {
'description': 'Incorrect return type',
},
}),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert err
assert err.value
assert 1 == len(err.value)
assert 'return' in err.value
assert (
f'expected [{get_type_repr.get_repr(pipeline.Response)}], but got '
f'{get_type_repr.get_repr(return_type if return_type else type(None))}'
) == err.value['return']
def test_omitted_return_code_couple_oas_resp(mocker: ptm.MockFixture) -> None:
test_returns = te.TypedDict( # type: ignore
'MissingHttpCode',
{'body': t.Dict[str, int]},
)
async def test() -> test_returns:
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
handler=test,
operation=_make_operation({
'200': {
'description': 'I am alone',
},
'300': {
'description': 'I am alone',
},
}),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert err
assert err.value
assert 1 == len(err.value)
assert 'return.http_code' in err.value
assert 'missing' == err.value['return.http_code']
def test_not_empty_signature(
caplog: logging.LogCaptureFixture,
mocker: ptm.MockFixture,
) -> None:
async def foo(
name: str,
foo: str,
bar: str,
lorem_ipsum: t.List[str],
) -> pipeline.Response:
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
handler=foo,
operation=list(
parser._resolve_operations(
components={},
paths={
'/{name}': {
'parameters': [
{
'name': 'name',
'in': 'path',
'required': True,
'schema': {
'type': 'string',
},
},
],
'post': {
'operationId': 'Thor',
'responses': {
'default': {
'description': 'fake',
},
},
},
},
},
), )[0],
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert len(err.value) == 3
assert err.value['foo'] == 'unexpected'
assert err.value['bar'] == 'unexpected'
assert err.value['lorem_ipsum'] == 'unexpected'
assert (
'Unconsumed arguments [foo, bar, lorem_ipsum] detected in Thor handler signature'
in caplog.messages)
def test_signature_empty_oas_cookies(
mocker: ptm.MockFixture,
caplog: logging.LogCaptureFixture,
) -> None:
async def foo(name: str) -> pipeline.Response:
...
hdrl = handler._resolve(
foo,
next(filter(lambda op: op.id == 'cookies_op', operations)),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
msg = (
'"cookies" found in operation but not in signature. '
'Please double check that. axion cannot infer a correctness of '
'this situations. If you wish to access any "cookies" defined in '
'specification, they have to be present in your handler '
'as '
)
assert id(hdrl.user_handler) == id(foo)
assert not hdrl.cookie_params
assert any(filter(lambda m: t.cast(str, m).startswith(msg), caplog.messages))
def test_valid_cookies_any_type(
the_type: t.Type[t.Any],
caplog: logging.LogCaptureFixture,
mocker: ptm.MockFixture,
) -> None:
async def foo(name: str, cookies: the_type) -> pipeline.Response: # type: ignore
...
hdrl = handler._resolve(
foo,
next(filter(lambda op: op.id == 'cookies_op', operations)),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert id(hdrl.user_handler) == id(foo)
assert hdrl.cookie_params
assert len(hdrl.cookie_params) == 2
assert ('csrftoken', 'csrftoken') in hdrl.cookie_params.items()
assert ('debug', 'debug') in hdrl.cookie_params.items()
msg = (
'Detected usage of "cookies" declared as typing.Any. '
'axion will allow such declaration but be warned that '
'you will loose all the help linters (like mypy) offer.'
)
assert msg in caplog.messages
def test_signature_all_missing(mocker: ptm.MockFixture) -> None:
async def foo() -> pipeline.Response:
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
handler=foo,
operation=operation,
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert err.value.operation_id == 'TestAnalysisParameters'
assert len(err.value) == 4
for key in ('id', 'limit', 'page', 'includeExtra'):
assert key in err.value
assert err.value[key] == 'missing'
def test_signature_set_bad_oas_cookies_unknown(
the_type: t.Type[t.Any],
extra_param: str,
mocker: ptm.MockFixture,
) -> None:
async def foo(name: str, cookies: the_type) -> pipeline.Response: # type: ignore
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
foo,
next(filter(lambda op: op.id == 'cookies_op', operations)),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert len(err.value) == 1
assert f'cookies.{extra_param}' in err.value
assert err.value[f'cookies.{extra_param}'] == 'unknown'
def test_correct_handler_no_oas_body(
response_code: int,
return_type: t.Type[t.Any],
mocker: ptm.MockFixture,
) -> None:
async def test() -> return_type: # type: ignore
...
operation = _make_operation({
f'{response_code}': {
'description': f'Returning {return_type}',
},
})
handler._resolve(
handler=test,
operation=operation,
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
def test_signature_mismatch_missing(mocker: ptm.MockFixture) -> None:
async def foo(
limit: t.Optional[int],
page: t.Optional[float],
include_extra: t.Optional[bool],
) -> pipeline.Response:
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
handler=foo,
operation=operation,
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert err.value.operation_id == 'TestAnalysisParameters'
assert len(err.value) == 1
assert 'id' in err.value
assert err.value['id'] == 'missing'
def test_signature_set_no_oas_cookies(
the_type: t.Type[t.Any],
caplog: logging.LogCaptureFixture,
mocker: ptm.MockFixture,
) -> None:
async def foo(name: str, cookies: the_type) -> pipeline.Response: # type: ignore
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
foo,
next(filter(lambda op: op.id == 'no_cookies_op', operations)),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert len(err.value) == 1
assert 'cookies' in err.value
assert err.value['cookies'] == 'unexpected'
assert '"cookies" found in signature but not in operation' in caplog.messages
def test_signature_set_bad_oas_cookies_type_mismatch(
the_type: t.Type[t.Any],
expected_errors: t.List[t.Tuple[str, str]],
mocker: ptm.MockFixture,
) -> None:
async def foo(name: str, cookies: the_type) -> pipeline.Response: # type: ignore
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
foo,
next(filter(lambda op: op.id == 'cookies_op', operations)),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert len(err.value) == len(expected_errors)
for param_key, error_msg in expected_errors:
assert f'cookies.{param_key}' in err.value
assert err.value[f'cookies.{param_key}'] == error_msg
def test_missing_return_annotation(mocker: ptm.MockFixture) -> None:
async def test(): # type: ignore
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
handler=test,
operation=_make_operation({
'204': {
'description': 'It will not work anyway',
},
}),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert err
assert err.value
assert 1 == len(err.value)
assert 'return' in err.value
assert 'missing' == err.value['return']
def test_omitted_return_code_single_oas_resp(
response_code: t.Union[str, te.Literal['default']],
mocker: ptm.MockFixture,
) -> None:
test_returns = te.TypedDict( # type: ignore
'MissingHttpCode',
{'body': t.Dict[str, int]},
)
async def test() -> test_returns:
...
handler._resolve(
handler=test,
operation=_make_operation({
f'{response_code}': {
'description': 'I am alone',
},
}),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
def test_incorrect_cookies_type(
cookies_type: t.Type[t.Any],
mocker: ptm.MockFixture,
) -> None:
test_returns = te.TypedDict( # type: ignore
'RV_Bad_Cookies',
{
'http_code': int,
'cookies': cookies_type
}, # type: ignore
)
async def test() -> test_returns:
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
handler=test,
operation=_make_operation({
'204': {
'description': 'Incorrect return type',
},
}),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert err
assert err.value
assert 1 == len(err.value)
assert 'return.cookies' in err.value
assert (f'expected ['
f'typing.Mapping[str, typing.Any],'
f'typing.Dict[str, typing.Any],'
f'typing_extensions.TypedDict], '
f'but got '
f'{get_type_repr.get_repr(cookies_type)}'
) == err.value['return.cookies']
def test_invalid_cookies_type(
op_id: str,
the_type: t.Type[t.Any],
mocker: ptm.MockFixture,
) -> None:
async def foo(name: str, cookies: the_type) -> pipeline.Response: # type: ignore
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
foo,
next(filter(lambda op: op.id == op_id, operations)),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert len(err.value) == 1
assert 'cookies' in err.value
assert err.value['cookies'] == (
f'expected [typing.Mapping[str, typing.Any],'
f'typing.Dict[str, typing.Any],typing_extensions.TypedDict]'
f', but got {get_type_repr.get_repr(the_type)}'
)
def test_signature_all_bad_type(mocker: ptm.MockFixture) -> None:
async def foo(
id: float,
limit: t.Optional[t.Union[float, int]],
page: t.Optional[t.AbstractSet[bool]],
include_extra: t.Union[int, str],
) -> pipeline.Response:
...
with pytest.raises(handler.InvalidHandlerError) as err:
handler._resolve(
handler=foo,
operation=operation,
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert err.value.operation_id == 'TestAnalysisParameters'
assert len(err.value) == 4
for mismatch in err.value:
actual_msg = err.value[mismatch.param_name]
expected_msg = None
if mismatch.param_name == 'id':
expected_msg = 'expected [str], but got float'
elif mismatch.param_name == 'limit':
expected_msg = ('expected [typing.Optional[int]], but got '
'typing.Optional[typing.Union[float, int]]')
elif mismatch.param_name == 'page':
expected_msg = ('expected [typing.Optional[float]], but got '
'typing.Optional[typing.AbstractSet[bool]]')
elif mismatch.param_name == 'includeExtra':
expected_msg = ('expected [typing.Optional[bool]], but got '
'typing.Union[int, str]')
assert expected_msg is not None
assert actual_msg == expected_msg
def test_signature_empty_no_oas_cookies(
mocker: ptm.MockFixture,
caplog: logging.LogCaptureFixture,
) -> None:
async def foo(name: str) -> pipeline.Response:
...
hdrl = handler._resolve(
foo,
next(filter(lambda op: op.id == 'no_cookies_op', operations)),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert id(hdrl.user_handler) == id(foo)
assert not hdrl.cookie_params
assert 'No "cookies" in signature and operation parameters' in caplog.messages
def test_signature_match(mocker: ptm.MockFixture) -> None:
async def test_handler(
id: str,
limit: t.Optional[int],
page: t.Optional[float],
include_extra: t.Optional[bool],
) -> pipeline.Response:
...
hdrl = handler._resolve(
handler=test_handler,
operation=operation,
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert len(hdrl.path_params) == 1
assert len(hdrl.query_params) == 3
def test_signature_set_oas_cookies(
the_type: t.Type[t.Any],
caplog: logging.LogCaptureFixture,
mocker: ptm.MockFixture,
) -> None:
async def foo(name: str, cookies: the_type) -> pipeline.Response: # type: ignore
...
hdrl = handler._resolve(
foo,
next(filter(lambda op: op.id == 'cookies_op', operations)),
request_processor=mocker.Mock(),
response_processor=mocker.Mock(),
)
assert id(hdrl.user_handler) == id(foo)
assert hdrl.cookie_params
assert ('csrftoken', 'csrftoken') in hdrl.cookie_params.items()
assert ('debug', 'debug') in hdrl.cookie_params.items()
assert '"cookies" found both in signature and operation' in caplog.messages
