def test_map_parameters_to_var_keyword(self, from_kind):
"""
Ensure the mapping **strategy** produced mapping *to* ``var-keyword``
- POSITIONAL_ONLY -> VAR_POSITIONAL (success)
- POSTIIONAL_OR_KEYWORD -> VAR_POSITIONAL (success)
- VAR_POSTIIONAL -> VAR_POSITIONAL (raises)
- KEYWORD_ONLY -> VAR_POSITIONAL (success)
- VAR_KEYWROD -> VAR_POSITIONAL (success)
"""
from_param = self.make_param('a', from_kind)
from_sig = inspect.Signature([from_param])
fsig = FSignature.from_native(from_sig)
to_param = self.make_param('kwargs', VAR_KEYWORD)
to_sig = inspect.Signature([to_param])
expected_exc = None
if from_param.kind is VAR_POSITIONAL:
expected_exc = TypeError(
"Missing requisite mapping from variable positional "
"parameter 'a'")
if expected_exc:
with pytest.raises(type(expected_exc)) as excinfo:
Mapper.map_parameters(fsig, to_sig)
assert excinfo.value.args[0] == expected_exc.args[0]
return
pmap = Mapper.map_parameters(fsig, to_sig)
assert pmap == {from_param.name: to_param.name}
def test_map_parameters_to_var_positional(self, from_kind):
"""
Ensure the mapping **strategy** produced mapping *to* ``var-positional``
- POSITIONAL_ONLY -> VAR_POSITIONAL (raises)
- POSTIIONAL_OR_KEYWORD -> VAR_POSITIONAL (raises)
- VAR_POSTIIONAL -> VAR_POSITIONAL (success)
- KEYWORD_ONLY -> VAR_POSITIONAL (raises)
- VAR_KEYWROD -> VAR_POSITIONAL (raises)
"""
from_param = self.make_param('from_', from_kind)
from_sig = inspect.Signature([from_param])
fsig = FSignature.from_native(from_sig)
to_param = self.make_param('args', VAR_POSITIONAL)
to_sig = inspect.Signature([to_param])
if from_param.kind is VAR_POSITIONAL:
pmap = Mapper.map_parameters(fsig, to_sig)
assert pmap == {from_param.name: to_param.name}
return
with pytest.raises(TypeError) as excinfo:
Mapper.map_parameters(fsig, to_sig)
if from_param.kind is VAR_KEYWORD:
assert excinfo.value.args[0] == (
"Missing requisite mapping from variable keyword parameter "
"'from_'")
else:
assert excinfo.value.args[0] == \
"Missing requisite mapping from parameters (from_)"
def test__call__defaults_applied(self, from_kind):
"""
Ensure that defaults are applied to the underlying params
(i.e. args passed):
- POSITIONAL_ONLY
- POSITIONAL_OR_KEYWORD
- KEYWORD_ONLY
"""
from_param = self.make_param('a', from_kind, default=1)
from_sig = inspect.Signature([from_param])
fsig = FSignature.from_native(from_sig)
func = lambda: None
func.__signature__ = \
inspect.Signature([inspect.Parameter('kwargs', VAR_KEYWORD)])
mapper = Mapper(fsig, func)
assert mapper() == CallArguments(a=1)
def test_map_parameters_to_empty(self, from_kind):
"""
Ensure mapping **strategy** failure when no interface param available.
"""
from_param = self.make_param('a', from_kind)
from_sig = inspect.Signature([from_param])
fsig = FSignature.from_native(from_sig)
to_sig = inspect.Signature()
with pytest.raises(TypeError) as excinfo:
Mapper.map_parameters(fsig, to_sig)
if from_param.kind in (VAR_KEYWORD, VAR_POSITIONAL):
assert excinfo.value.args[0] == (
"Missing requisite mapping from {from_kind} parameter 'a'".\
format(from_kind=_get_pk_string(from_kind))
)
else:
assert excinfo.value.args[0] == \
"Missing requisite mapping from parameters (a)"
def test_map_parameters_to_non_var_parameter(
self,
from_name,
from_kind,
from_default,
to_name,
to_kind,
to_default,
):
"""
Ensure the mapping **strategy** produced with input fparams of ``kind``:
- POSITIONAL_ONLY
- POSITIONAL_OR_KEYWORD
- KEYWORD_ONLY
to callable params of ``kind``:
- POSITIONAL_ONLY
- POSITIONAL_OR_KEYWORD
- KEYWORD_ONLY
with varrying ``name`` and ``default``
"""
# pylint: disable=R0913, too-many-arguments
# pylint: disable=R0914, too-many-locals
from_param = self.make_param(from_name, from_kind, from_default)
from_sig = inspect.Signature([from_param] if from_param else None)
fsig = FSignature.from_native(from_sig)
to_param = self.make_param(to_name, to_kind, to_default)
to_sig = inspect.Signature([to_param])
# Idenitfy map_parameters errors
expected_exc = None
if not from_param:
if to_param.default is empty.native:
expected_exc = TypeError(
"Missing requisite mapping to non-default "
"{to_kind} parameter '{to_name}'".format(
to_kind=_get_pk_string(to_param.kind),
to_name=to_param.name,
))
elif from_param.name != to_param.name:
if to_param.default is empty.native:
expected_exc = TypeError(
"Missing requisite mapping to non-default "
"{to_kind} parameter '{to_name}'".format(
to_kind=_get_pk_string(to_param.kind),
to_name=to_param.name,
))
else:
expected_exc = TypeError(
'Missing requisite mapping from parameters (a)')
if expected_exc:
with pytest.raises(type(expected_exc)) as excinfo:
Mapper.map_parameters(fsig, to_sig)
assert excinfo.value.args[0] == expected_exc.args[0]
return
pmap = Mapper.map_parameters(fsig, to_sig)
expected_pmap = {from_param.name: to_param.name} if from_param else {}
assert pmap == expected_pmap
