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_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 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_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_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_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 test_plainStrArgument(self):
inspectedArgument = InspectedArgument('myVar',
DType('builtins', 'str'))
resolvedArgument = self.__argumentResolver.resolve(
inspectedArgument, 'Hello')
self.assertEqual('Hello', resolvedArgument)
def test_explicitIntArgument(self):
inspectedArgument = InspectedArgument('myVar',
DType('builtins', 'int'))
resolvedArgument = self.__argumentResolver.resolve(
inspectedArgument, 123)
self.assertEqual(123, 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_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_argumentWithDefaultValue(self):
inspectedArgument = InspectedArgument('myVar',
DType('builtins',
'str'), 'Peter', True)
resolvedArgument = self.__argumentResolver.resolve(
inspectedArgument, None)
self.assertEqual('Peter', resolvedArgument)
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_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):
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 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_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_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_noValueNoTypehint(self):
inspectedArgument = InspectedArgument('myVar',
DType('inspect', '_empty'))
with self.assertRaises(Exception) as error:
self.__argumentResolver.resolve(inspectedArgument, None)
self.assertEqual(
'Argument "myVar" must either have explicit value, default value or typehint defined',
str(error.exception))
def test_strArgumentService(self):
inspectedArgument = InspectedArgument(
'myVar',
DType(ScriptSessionFactory.__module__, 'ScriptSessionFactory'))
resolvedSparkSessionFactory = self.__argumentResolver.resolve(
inspectedArgument, f'@{ScriptSessionFactory.__module__}')
self.assertIsInstance(resolvedSparkSessionFactory,
ScriptSessionFactory)
def test_generalService(self):
inspectedArgument = InspectedArgument(
'sparkSessionFactory',
DType(ScriptSessionFactory.__module__, 'ScriptSessionFactory'))
resolvedSparkSessionFactory = self.__argumentResolver.resolve(
inspectedArgument, None)
self.assertIsInstance(resolvedSparkSessionFactory,
ScriptSessionFactory)
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_undefined_service(self):
service_argument = ServiceArgument("foo.Bar")
inspected_argument = InspectedArgument("bar", DType("foo.Bar", "Bar"))
services2_classes = {}
aliases2_services = {}
with self.assertRaises(Exception) as error:
service_argument.check_type_matches_definition(
inspected_argument, services2_classes, aliases2_services)
self.assertEqual("Undefined service foo.Bar", str(error.exception))
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_undefinedService(self):
serviceArgument = ServiceArgument('foo.Bar')
inspectedArgument = InspectedArgument('bar', DType('foo.Bar', 'Bar'))
services2Classes = {}
aliases2Services = {}
with self.assertRaises(Exception) as error:
serviceArgument.checkTypeMatchesDefinition(inspectedArgument,
services2Classes,
aliases2Services)
self.assertEqual('Undefined service foo.Bar', str(error.exception))
def test_unknown_aliased_service(self):
service_argument = ServiceArgument("foo.BarAlias")
inspected_argument = InspectedArgument("bar", DType("foo.Bar", "Bar"))
services2_classes = {}
aliases2_services = {"foo.BarAlias": "foo.Bar"}
with self.assertRaises(Exception) as error:
service_argument.check_type_matches_definition(
inspected_argument, services2_classes, aliases2_services)
self.assertEqual('Aliased service "foo.Bar" does not exist',
str(error.exception))
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 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_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)
