def test_namedArguments(self):
resolvedArguments = [
ResolvedArgument(
'myNumber',
PrimitiveArgument(123, 'myNumber'),
InspectedArgument('myNumber', DType('builtins', 'int'))
),
ResolvedArgument(
'manuallyWiredService',
ServiceArgument('my.module.ManuallyWiredClass', 'manuallyWiredService'),
InspectedArgument('manuallyWiredService', DType('my.module.ManuallyWiredClass', 'ManuallyWiredClass'))
),
ResolvedArgument(
'autowiredService',
None,
InspectedArgument('autowiredService', DType('my.module.OtherClass', 'OtherClass')),
)
]
classes2Services = {
'my.module.OtherClass': {'OtherClass': ['my.module.OtherClass']}
}
newResolvedArguments = self.__argumentsAutowirer.autowire(
'my.module.MyClass',
resolvedArguments,
classes2Services,
)
self.assertEqual(3, len(newResolvedArguments))
self.assertEqual(PrimitiveArgument(123, 'myNumber'), newResolvedArguments[0].argument)
self.assertEqual(ServiceArgument('my.module.ManuallyWiredClass', 'manuallyWiredService'), newResolvedArguments[1].argument)
self.assertEqual(ServiceArgument('my.module.OtherClass', 'autowiredService'), newResolvedArguments[2].argument)
def resolve(self, resolvedArgument: ResolvedArgument,
containerBuild: ContainerBuild):
argument = resolvedArgument.argument
if not isinstance(argument, TaggedAliasedServiceArgument):
return resolvedArgument
servicesForTag = containerBuild.getServicesByTag(argument.tagName)
if isinstance(argument.tagAlias, str):
tagAlias = self.__resolveParameterValue(argument.tagAlias,
containerBuild.parameters)
else:
tagAlias = argument.tagAlias
for service in servicesForTag:
tagAttributes = service.getTagAttributes(argument.tagName)
if 'alias' not in tagAttributes:
raise Exception(
f'"alias" attribute is missing for tag {argument.tagName}')
if tagAttributes['alias'] == tagAlias:
resolvedArgument.modifyArgument(
ServiceArgument(service.name, argument.name),
'tagged_aliased')
return resolvedArgument
raise Exception(
f'No service tagged with {argument.tagName} found for alias: {tagAlias}'
)
def resolve(self, resolvedArgument: ResolvedArgument, containerBuild: ContainerBuild):
argument = resolvedArgument.argument
if not isinstance(argument, TaggedServicesArgument):
return resolvedArgument
servicesForTag = containerBuild.getServicesByTag(argument.tagName)
serviceArguments = list(map(lambda service: ServiceArgument(service.name), servicesForTag))
resolvedArgument.modifyArgument(ListArgument(serviceArguments, argument.name), 'tags')
return resolvedArgument
def test_no_change(self):
resolved_argument = ResolvedArgument("my_number", PrimitiveArgument(123), InspectedArgument("my_number", DType("builtins", "int")))
container_build = ContainerBuild({}, [], {}, {}, {})
new_resolved_argument = self.__tagged_argument_resolver.resolve(resolved_argument, container_build)
self.assertEqual(resolved_argument, new_resolved_argument)
def resolve(self, resolved_argument: ResolvedArgument,
container_build: ContainerBuild):
argument = resolved_argument.argument
if not isinstance(argument, TaggedServicesArgument):
return resolved_argument
services_for_tag = container_build.get_services_by_tag(
argument.tag_name)
service_arguments = list(
map(lambda service: ServiceArgument(service.name),
services_for_tag))
resolved_argument.modify_argument(
ListArgument(service_arguments, argument.name), "tags")
return resolved_argument
def test_basic(self):
self.__arguments_validator.validate(
"injecta.mocks.Bar",
[ResolvedArgument("name", PrimitiveArgument("Jiri Koutny"), InspectedArgument("name", DType("builtins", "str")))],
{},
{},
)
self.assertTrue(True)
def test_named_arguments(self):
resolved_arguments = [
ResolvedArgument(
"my_number", PrimitiveArgument(123, "my_number"),
InspectedArgument("my_number", DType("builtins", "int"))),
ResolvedArgument(
"manually_wired_service",
ServiceArgument("my.module.ManuallyWiredClass",
"manually_wired_service"),
InspectedArgument(
"manually_wired_service",
DType("my.module.ManuallyWiredClass",
"ManuallyWiredClass")),
),
ResolvedArgument(
"autowired_service",
None,
InspectedArgument("autowired_service",
DType("my.module.OtherClass", "OtherClass")),
),
]
classes2_services = {
"my.module.OtherClass": {
"OtherClass": ["my.module.OtherClass"]
}
}
new_resolved_arguments = self.__arguments_autowirer.autowire(
"my.module.MyClass",
resolved_arguments,
classes2_services,
)
self.assertEqual(3, len(new_resolved_arguments))
self.assertEqual(PrimitiveArgument(123, "my_number"),
new_resolved_arguments[0].argument)
self.assertEqual(
ServiceArgument("my.module.ManuallyWiredClass",
"manually_wired_service"),
new_resolved_arguments[1].argument)
self.assertEqual(
ServiceArgument("my.module.OtherClass", "autowired_service"),
new_resolved_arguments[2].argument)
def autowireArgument(resolvedArgument: ResolvedArgument):
if resolvedArgument.argument or resolvedArgument.inspectedArgument.hasDefaultValue(
):
return resolvedArgument
if resolvedArgument.inspectedArgument.dtype.moduleName == ContainerInterface.__module__:
serviceArgument = ServiceArgument('serviceContainer',
resolvedArgument.name)
resolvedArgument.modifyArgument(serviceArgument,
'container autowiring')
return resolvedArgument
serviceArgument = self.__argumentResolver.resolve(
resolvedArgument.inspectedArgument, serviceName,
classes2Services)
resolvedArgument.modifyArgument(serviceArgument, 'autowiring')
return resolvedArgument
def autowire_argument(resolved_argument: ResolvedArgument):
if resolved_argument.argument or resolved_argument.inspected_argument.has_default_value(
):
return resolved_argument
if resolved_argument.inspected_argument.dtype.module_name == ContainerInterface.__module__:
service_argument = ServiceArgument("service_container",
resolved_argument.name)
resolved_argument.modify_argument(service_argument,
"container autowiring")
return resolved_argument
service_argument = self.__argument_resolver.resolve(
resolved_argument.inspected_argument, service_name,
classes2_services)
resolved_argument.modify_argument(service_argument, "autowiring")
return resolved_argument
def test_noChange(self):
resolvedArgument = ResolvedArgument(
'myNumber', PrimitiveArgument(123),
InspectedArgument('myNumber', DType('builtins', 'int')))
containerBuild = ContainerBuild({}, [], {}, {}, {})
newResolvedArgument = self.__taggedArgumentResolver.resolve(
resolvedArgument, containerBuild)
self.assertEqual(resolvedArgument, newResolvedArgument)
def test_exception_object_for_string(self):
with self.assertRaises(Exception) as error:
self.__arguments_validator.validate(
"injecta.mocks.Bar",
[ResolvedArgument("name", ServiceArgument("injecta.mocks.Empty"), InspectedArgument("name", DType("builtins", "str")))],
{"injecta.mocks.Empty": DType("injecta.mocks.Empty", "Empty")},
{},
)
self.assertEqual(
'Expected dtype "str", got "injecta.mocks.Empty.Empty" (argument "name", service "injecta.mocks.Bar")', str(error.exception)
)
def __resolveArgumentsArgs(self, arguments: List[ArgumentInterface],
inspectedArguments: List[InspectedArgument]):
resolvedArguments = self.__resolveArguments(arguments,
inspectedArguments[0:-1])
startIndex = len(resolvedArguments)
for idx, argument in enumerate(arguments[startIndex:]):
resolvedArguments.append(
ResolvedArgument(f'arg_{idx}', argument, None))
return resolvedArguments
def test_exception_string_for_object(self):
with self.assertRaises(Exception) as error:
self.__arguments_validator.validate(
"injecta.mocks.Foo",
[ResolvedArgument("bar", PrimitiveArgument("Jiri Koutny"), InspectedArgument("bar", DType("injecta.mocks.Bar", "Bar")))],
{},
{},
)
self.assertEqual(
'Expected dtype "injecta.mocks.Bar.Bar", got "str" (argument "bar", service "injecta.mocks.Foo")', str(error.exception)
)
def test_basic(self):
resolved_argument = ResolvedArgument(
"my_number", TaggedServicesArgument("my_service_tag"), InspectedArgument("my_tagged_services", DType("builtins", "list"))
)
new_resolved_argument = self.__tagged_argument_resolver.resolve(resolved_argument, self.__create_container_build())
list_argument = new_resolved_argument.argument
self.assertIsInstance(list_argument, ListArgument)
self.assertEqual(None, list_argument.name)
self.assertEqual("injecta.mocks.Bar", list_argument.items[0].service_name)
self.assertEqual("injecta.mocks.Bar.new", list_argument.items[1].service_name)
def test_basic(self):
self.__argumentsValidator.validate(
'injecta.mocks.Bar',
[
ResolvedArgument(
'name', PrimitiveArgument('Jiri Koutny'),
InspectedArgument('name', DType('builtins', 'str')))
],
{},
{},
)
self.assertTrue(True)
def resolve(self, resolved_argument: ResolvedArgument, container_build: ContainerBuild):
argument = resolved_argument.argument
if not isinstance(argument, TaggedAliasedServiceArgument):
return resolved_argument
services_for_tag = container_build.get_services_by_tag(argument.tag_name)
if isinstance(argument.tag_alias, str):
tag_alias = self.__resolve_parameter_value(argument.tag_alias, container_build.parameters)
else:
tag_alias = argument.tag_alias
for service in services_for_tag:
tag_attributes = service.get_tag_attributes(argument.tag_name)
if "alias" not in tag_attributes:
raise Exception(f'"alias" attribute is missing for tag {argument.tag_name}')
if tag_attributes["alias"] == tag_alias:
resolved_argument.modify_argument(ServiceArgument(service.name, argument.name), "tagged_aliased")
return resolved_argument
raise Exception(f"No service tagged with {argument.tag_name} found for alias: {tag_alias}")
def __resolve_arguments_kwargs(
self, arguments_indexed: Dict[str, ArgumentInterface],
inspected_arguments_indexed: Dict[str, InspectedArgument]):
del inspected_arguments_indexed["kwargs"]
resolved_arguments = self.__resolve_arguments(
arguments_indexed, inspected_arguments_indexed)
for resolved_argument in resolved_arguments:
del arguments_indexed[resolved_argument.name]
for _, argument in arguments_indexed.items():
resolved_arguments.append(
ResolvedArgument(argument.name, argument, None))
return resolved_arguments
def test_exceptionObjectForString(self):
with self.assertRaises(Exception) as error:
self.__argumentsValidator.validate(
'injecta.mocks.Bar',
[
ResolvedArgument(
'name', ServiceArgument('injecta.mocks.Empty'),
InspectedArgument('name', DType('builtins', 'str')))
],
{'injecta.mocks.Empty': DType('injecta.mocks.Empty', 'Empty')},
{},
)
self.assertEqual(
'Expected dtype "str", got "injecta.mocks.Empty.Empty" (argument "name", service "injecta.mocks.Bar")',
str(error.exception))
def test_basic(self):
resolvedArgument = ResolvedArgument(
'myNumber', TaggedServicesArgument('myServiceTag'),
InspectedArgument('myTaggedServices', DType('builtins', 'list')))
newResolvedArgument = self.__taggedArgumentResolver.resolve(
resolvedArgument, self.__createContainerBuild())
listArgument = newResolvedArgument.argument
self.assertIsInstance(listArgument, ListArgument)
self.assertEqual(None, listArgument.name)
self.assertEqual('injecta.mocks.Bar',
listArgument.items[0].serviceName)
self.assertEqual('injecta.mocks.Bar.new',
listArgument.items[1].serviceName)
def test_exceptionStringForObject(self):
with self.assertRaises(Exception) as error:
self.__argumentsValidator.validate(
'injecta.mocks.Foo',
[
ResolvedArgument(
'bar', PrimitiveArgument('Jiri Koutny'),
InspectedArgument('bar',
DType('injecta.mocks.Bar', 'Bar')))
],
{},
{},
)
self.assertEqual(
'Expected dtype "injecta.mocks.Bar.Bar", got "str" (argument "bar", service "injecta.mocks.Foo")',
str(error.exception))
def __resolveArguments(self, arguments: List[ArgumentInterface],
inspectedArguments: List[InspectedArgument]):
resolvedArguments = []
argumentCount = len(arguments)
for idx, inspectedArgument in enumerate(inspectedArguments):
argument = arguments[idx] if idx < argumentCount else None
# argument with default value, no value defined in service configuration
if inspectedArgument.hasDefaultValue() and argument is None:
continue
resolvedArgument = ResolvedArgument(inspectedArgument.name,
argument, inspectedArgument)
resolvedArguments.append(resolvedArgument)
return resolvedArguments
def __resolve_arguments(
self, arguments_indexed: Dict[str, ArgumentInterface],
inspected_arguments_indexed: Dict[str, InspectedArgument]):
resolved_arguments = []
for argument_name, inspected_argument in inspected_arguments_indexed.items(
):
argument = arguments_indexed[
argument_name] if argument_name in arguments_indexed else None
# argument with default value, no value defined in service configuration
if inspected_argument.has_default_value() and argument is None:
continue
resolved_argument = ResolvedArgument(inspected_argument.name,
argument, inspected_argument)
resolved_arguments.append(resolved_argument)
return resolved_arguments
