def test__get_normalized_kwargs(self):
def f(a, b, c):
raise NotImplementedError()
sig = FunctionSignature(f)
self.assertEquals(
sig.get_normalized_args((1,2,3), {}),
dict(a=1, b=2, c=3)
)
with self.assertRaises(SignatureException):
sig.get_normalized_args((1, 2, 3), dict(a=1))
def _test_function_signature(self,
func,
expected_signature,
has_varargs=False,
has_varkwargs=False
):
sig = FunctionSignature(func)
self.assertEquals(len(expected_signature), len(sig._args))
self.assertEquals(len(expected_signature), sig.get_num_args())
for expected_arg, arg in zip(expected_signature, sig._args):
if isinstance(expected_arg, tuple):
expected_arg = ExpectedArg(*expected_arg)
self.assertEquals(expected_arg.name,
arg.name)
self.assertEquals(expected_arg.has_default,
arg.has_default())
if expected_arg.has_default:
self.assertEquals(expected_arg.default, arg.default)
self.assertEquals(sig.has_variable_kwargs(), has_varkwargs)
self.assertEquals(sig.has_variable_args(), has_varargs)
self._test_missing_arguments(sig, expected_signature)
def test__get_normalized_kwargs_unknown_keywords(self):
def f(a, b, c, *args):
raise NotImplementedError()
sig = FunctionSignature(f)
with self.assertRaises(UnknownArguments):
sig.get_normalized_args((1, 2, 3, 4), dict(d=5))
def test__get_normalized_kwargs_missing_positionals(self):
def f(a, b, c, **kwargs):
raise NotImplementedError()
sig = FunctionSignature(f)
with self.assertRaises(MissingArguments):
sig.get_normalized_args((1,), dict(b=2, d=5))
def test__binary_global_function(self):
sig = FunctionSignature(time.time)
self.assertEquals(sig._args, [])
self.assertTrue(sig.has_variable_args())
self.assertTrue(sig.has_variable_kwargs())
def test__normalizing_kwargs_with_numbers(self):
# this is supported in python, but interferes with the arg-normalizing logic
sig = FunctionSignature(lambda *args, **kwargs: None)
with self.assertRaises(InvalidKeywordArgument):
sig.get_normalized_args((), {1:2})
