class ServiceResolver:
def __init__(self):
self.__inspectedArgumentsResolver = InspectedArgumentsResolver()
self.__argumentsValidator = ArgumentsValidator()
self.__argumentListResolver = ArgumentListResolver()
self.__namedArgumentsResolver = NamedArgumentsResolver()
def resolve(self, service: Service, services2Classes: dict,
aliases2Services: dict) -> ResolvedService:
if service.usesFactory():
factoryClass = services2Classes[service.factoryService.serviceName]
inspectedArguments = self.__inspectedArgumentsResolver.resolveMethod(
factoryClass, service.factoryMethod)
else:
inspectedArguments = self.__inspectedArgumentsResolver.resolveConstructor(
service.class_)
if service.hasNamedArguments():
resolvedArguments = self.__namedArgumentsResolver.resolve(
service.arguments, inspectedArguments, service.name)
else:
resolvedArguments = self.__argumentListResolver.resolve(
service.arguments, inspectedArguments, service.name)
if not service.usesFactory():
self.__argumentsValidator.validate(service.name, resolvedArguments,
services2Classes,
aliases2Services)
return ResolvedService(service, resolvedArguments)
class ServiceResolver:
def __init__(self):
self.__inspected_arguments_resolver = InspectedArgumentsResolver()
self.__arguments_validator = ArgumentsValidator()
self.__argument_list_resolver = ArgumentListResolver()
self.__named_arguments_resolver = NamedArgumentsResolver()
def resolve(self, service: Service, services2_classes: dict,
aliases2_services: dict) -> ResolvedService:
if service.uses_factory():
if service.factory_service.service_name not in services2_classes:
raise Exception(
f"Factory service {service.factory_service.service_name} not found"
)
factory_class = services2_classes[
service.factory_service.service_name]
inspected_arguments = self.__inspected_arguments_resolver.resolve_method(
factory_class, service.factory_method)
else:
inspected_arguments = self.__inspected_arguments_resolver.resolve_constructor(
service.class_)
if service.has_named_arguments():
resolved_arguments = self.__named_arguments_resolver.resolve(
service.arguments, inspected_arguments, service.name)
else:
resolved_arguments = self.__argument_list_resolver.resolve(
service.arguments, inspected_arguments, service.name)
if not service.uses_factory():
self.__arguments_validator.validate(service.name,
resolved_arguments,
services2_classes,
aliases2_services)
return ResolvedService(service, resolved_arguments)
def setUp(self):
self.__named_arguments_resolver = NamedArgumentsResolver()
self.__inspected_arguments_resolver = InspectedArgumentsResolver()
class NamedArgumentsResolverTest(unittest.TestCase):
def setUp(self):
self.__named_arguments_resolver = NamedArgumentsResolver()
self.__inspected_arguments_resolver = InspectedArgumentsResolver()
def test_basic_with_default_value(self):
arguments = [
PrimitiveArgument(111, "number_with_default"),
PrimitiveArgument("Peter", "name"),
]
inspected_arguments = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.Bar", "Bar"))
resolved_arguments = self.__named_arguments_resolver.resolve(
arguments, inspected_arguments, "injecta.mocks.Bar")
self.assertEqual(2, len(resolved_arguments))
self.assertEqual(PrimitiveArgument("Peter", "name"),
resolved_arguments[0].argument)
self.assertEqual(PrimitiveArgument(111, "number_with_default"),
resolved_arguments[1].argument)
def test_too_many_arguments(self):
arguments = [
PrimitiveArgument("Peter", "name"),
PrimitiveArgument(111, "number_with_default"),
PrimitiveArgument(True, "bool_with_default"),
PrimitiveArgument(222, "some_nonexistent_name"),
]
inspected_arguments = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.Bar", "Bar"))
with self.assertRaises(Exception) as error:
self.__named_arguments_resolver.resolve(arguments,
inspected_arguments,
"injecta.mocks.Bar")
self.assertEqual(
'Unknown argument "some_nonexistent_name" in service "injecta.mocks.Bar"',
str(error.exception))
def test_args(self):
arguments = [
PrimitiveArgument("George", "name"),
]
inspected_arguments = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.Args", "Args"))
resolved_arguments = self.__named_arguments_resolver.resolve(
arguments, inspected_arguments, "injecta.mocks.Args")
self.assertEqual(1, len(resolved_arguments))
self.assertEqual(PrimitiveArgument("George", "name"),
resolved_arguments[0].argument)
def test_kwargs(self):
arguments = [
PrimitiveArgument(111, "some_number"),
PrimitiveArgument("George", "name"),
PrimitiveArgument(True, "some_bool"),
]
inspected_arguments = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.Kwargs", "Kwargs"))
resolved_arguments = self.__named_arguments_resolver.resolve(
arguments, inspected_arguments, "injecta.mocks.Kwargs")
self.assertEqual(3, len(resolved_arguments))
self.assertEqual(PrimitiveArgument("George", "name"),
resolved_arguments[0].argument)
self.assertEqual(PrimitiveArgument(111, "some_number"),
resolved_arguments[1].argument)
self.assertEqual(PrimitiveArgument(True, "some_bool"),
resolved_arguments[2].argument)
def test_args_kwargs(self):
arguments = [
PrimitiveArgument(111, "some_number"),
PrimitiveArgument("George", "name"),
PrimitiveArgument(True, "some_bool"),
]
inspected_arguments = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.ArgsKwargs", "ArgsKwargs"))
resolved_arguments = self.__named_arguments_resolver.resolve(
arguments, inspected_arguments, "injecta.mocks.ArgsKwargs")
self.assertEqual(3, len(resolved_arguments))
self.assertEqual(PrimitiveArgument("George", "name"),
resolved_arguments[0].argument)
self.assertEqual(PrimitiveArgument(111, "some_number"),
resolved_arguments[1].argument)
self.assertEqual(PrimitiveArgument(True, "some_bool"),
resolved_arguments[2].argument)
class NamedArgumentsResolverTest(unittest.TestCase):
def setUp(self):
self.__namedArgumentsResolver = NamedArgumentsResolver()
self.__inspectedArgumentsResolver = InspectedArgumentsResolver()
def test_basicWithDefaultValue(self):
arguments = [
PrimitiveArgument(111, 'numberWithDefault'),
PrimitiveArgument('Peter', 'name'),
]
inspectedArguments = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.Bar', 'Bar'))
resolvedArguments = self.__namedArgumentsResolver.resolve(
arguments, inspectedArguments, 'injecta.mocks.Bar')
self.assertEqual(2, len(resolvedArguments))
self.assertEqual(PrimitiveArgument('Peter', 'name'),
resolvedArguments[0].argument)
self.assertEqual(PrimitiveArgument(111, 'numberWithDefault'),
resolvedArguments[1].argument)
def test_tooManyArguments(self):
arguments = [
PrimitiveArgument('Peter', 'name'),
PrimitiveArgument(111, 'numberWithDefault'),
PrimitiveArgument(True, 'boolWithDefault'),
PrimitiveArgument(222, 'someNonexistentName'),
]
inspectedArguments = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.Bar', 'Bar'))
with self.assertRaises(Exception) as error:
self.__namedArgumentsResolver.resolve(arguments,
inspectedArguments,
'injecta.mocks.Bar')
self.assertEqual(
'Unknown argument "someNonexistentName" in service "injecta.mocks.Bar"',
str(error.exception))
def test_args(self):
arguments = [
PrimitiveArgument('George', 'name'),
]
inspectedArguments = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.Args', 'Args'))
resolvedArguments = self.__namedArgumentsResolver.resolve(
arguments, inspectedArguments, 'injecta.mocks.Args')
self.assertEqual(1, len(resolvedArguments))
self.assertEqual(PrimitiveArgument('George', 'name'),
resolvedArguments[0].argument)
def test_kwargs(self):
arguments = [
PrimitiveArgument(111, 'someNumber'),
PrimitiveArgument('George', 'name'),
PrimitiveArgument(True, 'someBool'),
]
inspectedArguments = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.Kwargs', 'Kwargs'))
resolvedArguments = self.__namedArgumentsResolver.resolve(
arguments, inspectedArguments, 'injecta.mocks.Kwargs')
self.assertEqual(3, len(resolvedArguments))
self.assertEqual(PrimitiveArgument('George', 'name'),
resolvedArguments[0].argument)
self.assertEqual(PrimitiveArgument(111, 'someNumber'),
resolvedArguments[1].argument)
self.assertEqual(PrimitiveArgument(True, 'someBool'),
resolvedArguments[2].argument)
def test_argsKwargs(self):
arguments = [
PrimitiveArgument(111, 'someNumber'),
PrimitiveArgument('George', 'name'),
PrimitiveArgument(True, 'someBool'),
]
inspectedArguments = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.ArgsKwargs', 'ArgsKwargs'))
resolvedArguments = self.__namedArgumentsResolver.resolve(
arguments, inspectedArguments, 'injecta.mocks.ArgsKwargs')
self.assertEqual(3, len(resolvedArguments))
self.assertEqual(PrimitiveArgument('George', 'name'),
resolvedArguments[0].argument)
self.assertEqual(PrimitiveArgument(111, 'someNumber'),
resolvedArguments[1].argument)
self.assertEqual(PrimitiveArgument(True, 'someBool'),
resolvedArguments[2].argument)
class InspectedArgumentsResolverTest(unittest.TestCase):
def setUp(self):
self.__inspected_arguments_resolver = InspectedArgumentsResolver()
def test_empty_class(self):
result = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.Empty", "Empty"))
self.assertEqual([], result)
def test_basic_class(self):
result = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.Foo", "Foo"))
expected_result = [
InspectedArgument("bar", DType("injecta.mocks.Bar", "Bar"))
]
self.assertEqual(expected_result, result)
def test_with_default_values(self):
result = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.Bar", "Bar"))
expected_arguments = [
InspectedArgument("name", DType("builtins", "str")),
InspectedArgument("number_with_default", DType("builtins", "int"),
0),
InspectedArgument("bool_with_default", DType("builtins", "bool"),
False),
]
self.assertEqual(expected_arguments, result)
def test_with_default_none_value(self):
result = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.NoneClass", "NoneClass"))
expected_arguments = [
InspectedArgument("name", DType("builtins", "str")),
InspectedArgument("some_none_value", DType("builtins", "int"),
None),
]
self.assertEqual(expected_arguments, result)
self.assertTrue(result[1].has_default_value())
def test_with_object_list(self):
result = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.ObjectList", "ObjectList"))
expected_arguments = [
InspectedArgument("objects",
ListType("injecta.mocks.Empty", "Empty")),
InspectedArgument("name", DType("builtins", "str"), "my_name"),
]
self.assertEqual(expected_arguments, result)
def test_use_parent_constructor(self):
result = self.__inspected_arguments_resolver.resolve_constructor(
DType("injecta.mocks.UseParentConstructor",
"UseParentConstructor"))
expected_arguments = [
InspectedArgument("name", DType("builtins", "str")),
InspectedArgument("number_with_default", DType("builtins", "int"),
0),
InspectedArgument("bool_with_default", DType("builtins", "bool"),
False),
]
self.assertEqual(expected_arguments, result)
def __init__(self):
self.__inspected_arguments_resolver = InspectedArgumentsResolver()
self.__arguments_validator = ArgumentsValidator()
def __init__(self):
self.__inspectedArgumentsResolver = InspectedArgumentsResolver()
self.__argumentsValidator = ArgumentsValidator()
self.__argumentListResolver = ArgumentListResolver()
self.__namedArgumentsResolver = NamedArgumentsResolver()
def setUp(self):
self.__inspectedArgumentsResolver = InspectedArgumentsResolver()
class InspectedArgumentsResolverTest(unittest.TestCase):
def setUp(self):
self.__inspectedArgumentsResolver = InspectedArgumentsResolver()
def test_emptyClass(self):
result = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.Empty', 'Empty'))
self.assertEqual([], result)
def test_basicClass(self):
result = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.Foo', 'Foo'))
expectedResult = [
InspectedArgument('bar', DType('injecta.mocks.Bar', 'Bar'))
]
self.assertEqual(expectedResult, result)
def test_withDefaultValues(self):
result = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.Bar', 'Bar'))
expectedArguments = [
InspectedArgument('name', DType('builtins', 'str')),
InspectedArgument('numberWithDefault', DType('builtins', 'int'),
0),
InspectedArgument('boolWithDefault', DType('builtins', 'bool'),
False),
]
self.assertEqual(expectedArguments, result)
def test_withDefaultNoneValue(self):
result = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.NoneClass', 'NoneClass'))
expectedArguments = [
InspectedArgument('name', DType('builtins', 'str')),
InspectedArgument('someNoneValue', DType('builtins', 'int'), None),
]
self.assertEqual(expectedArguments, result)
self.assertTrue(result[1].hasDefaultValue())
def test_withObjectList(self):
result = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.ObjectList', 'ObjectList'))
expectedArguments = [
InspectedArgument('objects',
ListType('injecta.mocks.Empty', 'Empty')),
InspectedArgument('name', DType('builtins', 'str'), 'myName'),
]
self.assertEqual(expectedArguments, result)
def test_useParentConstructor(self):
result = self.__inspectedArgumentsResolver.resolveConstructor(
DType('injecta.mocks.UseParentConstructor',
'UseParentConstructor'))
expectedArguments = [
InspectedArgument('name', DType('builtins', 'str')),
InspectedArgument('numberWithDefault', DType('builtins', 'int'),
0),
InspectedArgument('boolWithDefault', DType('builtins', 'bool'),
False),
]
self.assertEqual(expectedArguments, result)