def test_basic(self):
raw_services = {
"injecta.mocks.Bar.Bar": {"arguments": ["Jiri Koutny"]},
"injecta.mocks.Foo.Foo": {"arguments": ["@injecta.mocks.Bar.Bar"]},
"injecta.mocks.Bar.BarAlias": "@injecta.mocks.Bar.Bar",
}
expected_service1 = Service(
"injecta.mocks.Bar.Bar",
DType("injecta.mocks.Bar", "Bar"),
[
PrimitiveArgument("Jiri Koutny"),
],
)
expected_service2 = Service(
"injecta.mocks.Foo.Foo",
DType("injecta.mocks.Foo", "Foo"),
[
ServiceArgument("injecta.mocks.Bar.Bar"),
],
)
expected_alias1 = ServiceAlias("injecta.mocks.Bar.BarAlias", "injecta.mocks.Bar.Bar")
services, aliases = self.__services_preparer.prepare(raw_services)
self.assertEqual(expected_service1, services[0])
self.assertEqual(expected_service2, services[1])
self.assertEqual(expected_alias1, aliases[0])
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 test_basic(self):
serviceArgument = ServiceArgument('foo.Bar')
inspectedArgument = InspectedArgument('bar', DType('foo.Bar', 'Bar'))
services2Classes = {'foo.Bar': DType('foo.Bar', 'Bar')}
aliases2Services = {}
serviceArgument.checkTypeMatchesDefinition(inspectedArgument,
services2Classes,
aliases2Services)
def __create_container_build(self):
tags2_services = {
"my_service_tag": [
Service("injecta.mocks.Bar", DType("injecta.mocks.Bar", "Bar")),
Service("injecta.mocks.Bar.new", DType("injecta.mocks.Bar", "Bar")),
]
}
return ContainerBuild({}, [], {}, {}, tags2_services)
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_basic(self):
service_argument = ServiceArgument("foo.Bar")
inspected_argument = InspectedArgument("bar", DType("foo.Bar", "Bar"))
services2_classes = {"foo.Bar": DType("foo.Bar", "Bar")}
aliases2_services = {}
service_argument.check_type_matches_definition(inspected_argument,
services2_classes,
aliases2_services)
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_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_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_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 __createContainerBuild(self):
tags2Services = {
'myServiceTag': [
Service('injecta.mocks.Bar', DType('injecta.mocks.Bar',
'Bar')),
Service('injecta.mocks.Bar.new',
DType('injecta.mocks.Bar', 'Bar'))
]
}
return ContainerBuild({}, [], {}, {}, tags2Services)
def test_interface(self):
serviceArgument = ServiceArgument('injecta.mocks.Bar')
inspectedArgument = InspectedArgument(
'bar', DType('injecta.mocks.BarInterface', 'BarInterface'))
services2Classes = {
'injecta.mocks.Bar': DType('injecta.mocks.Bar', 'Bar')
}
aliases2Services = {}
serviceArgument.checkTypeMatchesDefinition(inspectedArgument,
services2Classes,
aliases2Services)
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_interface(self):
service_argument = ServiceArgument("injecta.mocks.Bar")
inspected_argument = InspectedArgument(
"bar", DType("injecta.mocks.BarInterface", "BarInterface"))
services2_classes = {
"injecta.mocks.Bar": DType("injecta.mocks.Bar", "Bar")
}
aliases2_services = {}
service_argument.check_type_matches_definition(inspected_argument,
services2_classes,
aliases2_services)
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_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_multilineScript(self):
d1 = Service('foo.Bar', DType('foo.Bar', 'Bar'),
[PrimitiveArgument('ahoj'),
PrimitiveArgument(52)], ['console.command'])
d2 = Service('hello.World_service', DType('hello.World', 'World'), [],
['my.tag'])
d3 = Service('my.Name', DType('my.Name', 'Name'), [],
['console.command'])
result = self.__tag2ServicesPreparer.prepare([d1, d2, d3])
expected = {'console.command': [d1, d3], 'my.tag': [d2]}
self.assertEqual(expected, result)
def test_multiline_script(self):
d1 = Service("foo.Bar", DType("foo.Bar", "Bar"),
[PrimitiveArgument("ahoj"),
PrimitiveArgument(52)], ["console.command"])
d2 = Service("hello.World_service", DType("hello.World", "World"), [],
["my.tag"])
d3 = Service("my.Name", DType("my.Name", "Name"), [],
["console.command"])
result = self.__tag2_services_preparer.prepare([d1, d2, d3])
expected = {"console.command": [d1, d3], "my.tag": [d2]}
self.assertEqual(expected, result)
def test_service_with_no_args(self):
result = self.__service_parser.parse("injecta.api.ApiClient.ApiClient",
None)
expected = Service("injecta.api.ApiClient.ApiClient",
DType("injecta.api.ApiClient", "ApiClient"))
self.assertEqual(expected, result)
def test_basic(self):
result = self.__typeResolver.resolve(
'injecta.parameter.ParametersParser')
self.assertEqual(
DType('injecta.parameter.ParametersParser', 'ParametersParser'),
result)
def test_basic(self):
result = self.__type_resolver.resolve(
"injecta.parameter.ParametersParser")
self.assertEqual(
DType("injecta.parameter.ParametersParser", "ParametersParser"),
result)
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_serviceWithNoArgs(self):
result = self.__serviceParser.parse('injecta.api.ApiClient.ApiClient', None)
expected = Service(
'injecta.api.ApiClient.ApiClient',
DType('injecta.api.ApiClient', 'ApiClient')
)
self.assertEqual(expected, result)
def test_explicitIntArgument(self):
inspectedArgument = InspectedArgument('myVar',
DType('builtins', 'int'))
resolvedArgument = self.__argumentResolver.resolve(
inspectedArgument, 123)
self.assertEqual(123, resolvedArgument)
def test_plainStrArgument(self):
inspectedArgument = InspectedArgument('myVar',
DType('builtins', 'str'))
resolvedArgument = self.__argumentResolver.resolve(
inspectedArgument, 'Hello')
self.assertEqual('Hello', resolvedArgument)
def test_argumentWithDefaultValue(self):
inspectedArgument = InspectedArgument('myVar',
DType('builtins',
'str'), 'Peter', True)
resolvedArgument = self.__argumentResolver.resolve(
inspectedArgument, None)
self.assertEqual('Peter', resolvedArgument)
def test_logger(self):
inspectedArgument = InspectedArgument('myLogger',
DType('logging', 'Logger'))
resolvedLogger = self.__argumentResolver.resolve(
inspectedArgument, None)
self.assertIsInstance(resolvedLogger, logging.Logger)
self.assertEqual('test_logger', resolvedLogger.name)
def test_strArgumentWithPlaceholders(self):
inspectedArgument = InspectedArgument('myVar',
DType('builtins', 'str'),
'Some default hello', True)
resolvedArgument = self.__argumentResolver.resolve(
inspectedArgument, 'Hello %name% %surname%')
self.assertEqual('Hello Peter Novak', resolvedArgument)
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 test_generalService(self):
inspectedArgument = InspectedArgument(
'sparkSessionFactory',
DType(ScriptSessionFactory.__module__, 'ScriptSessionFactory'))
resolvedSparkSessionFactory = self.__argumentResolver.resolve(
inspectedArgument, None)
self.assertIsInstance(resolvedSparkSessionFactory,
ScriptSessionFactory)
