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)