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 parse(self, argument, name=None): if isinstance(argument, str): if argument[0:1] == '@': return ServiceArgument(argument[1:], name) return PrimitiveArgument(argument, name) if isinstance(argument, TaggedServices): return TaggedServicesArgument(argument.val, name) if isinstance(argument, TaggedAliasedService): return TaggedAliasedServiceArgument(argument.tagName, argument.tagAlias, name) if isinstance(argument, (int, bool)): return PrimitiveArgument(argument, name) if isinstance(argument, list): return ListArgument(list(map(self.parse, argument)), name) if isinstance(argument, dict): return DictArgument( {k: self.parse(v) for k, v in argument.items()}, name) raise Exception('Unexpected argument type: {}'.format(type(argument)))
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_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_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_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_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_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_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_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_basic(self): self.__arguments_validator.validate( "injecta.mocks.Bar", [ResolvedArgument("name", PrimitiveArgument("Jiri Koutny"), InspectedArgument("name", DType("builtins", "str")))], {}, {}, ) self.assertTrue(True)
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_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_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_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_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): result = self.__service_parser.parse( "injecta.api.ApiClient_test", { "class": "injecta.api.ApiClient.ApiClient", "autowire": True, "arguments": ["Jirka", 15, False, "@injecta.api.Connector"] }, ) expected = Service( "injecta.api.ApiClient_test", DType("injecta.api.ApiClient", "ApiClient"), [ PrimitiveArgument("Jirka"), PrimitiveArgument(15), PrimitiveArgument(False), ServiceArgument("injecta.api.Connector"), ], ) expected.set_autowire(True) self.assertEqual(expected, result)
def test_basic(self): self.__argumentsValidator.validate( 'injecta.mocks.Bar', [ ResolvedArgument( 'name', PrimitiveArgument('Jiri Koutny'), InspectedArgument('name', DType('builtins', 'str'))) ], {}, {}, ) self.assertTrue(True)
def test_basic(self): result = self.__serviceParser.parse('injecta.api.ApiClient_test', { 'class': 'injecta.api.ApiClient.ApiClient', 'autowire': True, 'arguments': [ 'Jirka', 15, False, '@injecta.api.Connector' ] }) expected = Service( 'injecta.api.ApiClient_test', DType('injecta.api.ApiClient', 'ApiClient'), [ PrimitiveArgument('Jirka'), PrimitiveArgument(15), PrimitiveArgument(False), ServiceArgument('injecta.api.Connector'), ] ) expected.setAutowire(True) self.assertEqual(expected, result)
def test_factory(self): result = self.__serviceParser.parse('injecta.api.ApiClient', { 'factory': ['@injecta.api.ApiClientFactory.ApiClientFactory', 'create'], 'arguments': [ 'Jirka', ] }) expected = Service( 'injecta.api.ApiClient', DType('injecta.api', 'ApiClient'), [ PrimitiveArgument('Jirka'), ] ) expected.setFactory(ServiceArgument('injecta.api.ApiClientFactory.ApiClientFactory'), 'create') self.assertEqual(expected, result)
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 test_basic(self): rawServices = { 'injecta.mocks.Bar.Bar': { 'arguments': [ 'Jiri Koutny' ] }, 'injecta.mocks.Foo.Foo': { 'arguments': [ '@injecta.mocks.Bar.Bar' ] }, 'injecta.mocks.Bar.BarAlias': '@injecta.mocks.Bar.Bar', } expectedService1 = Service( 'injecta.mocks.Bar.Bar', DType('injecta.mocks.Bar', 'Bar'), [ PrimitiveArgument('Jiri Koutny'), ] ) expectedService2 = Service( 'injecta.mocks.Foo.Foo', DType('injecta.mocks.Foo', 'Foo'), [ ServiceArgument('injecta.mocks.Bar.Bar'), ] ) expectedAlias1 = ServiceAlias('injecta.mocks.Bar.BarAlias', 'injecta.mocks.Bar.Bar') services, aliases = self.__servicesPreparer.prepare(rawServices) self.assertEqual(expectedService1, services[0]) self.assertEqual(expectedService2, services[1]) self.assertEqual(expectedAlias1, aliases[0])
def test_factory(self): result = self.__service_parser.parse( "injecta.api.ApiClient", { "factory": ["@injecta.api.ApiClientFactory.ApiClientFactory", "create"], "arguments": [ "Jirka", ], }, ) expected = Service( "injecta.api.ApiClient", DType("injecta.api", "ApiClient"), [ PrimitiveArgument("Jirka"), ], ) expected.set_factory( ServiceArgument("injecta.api.ApiClientFactory.ApiClientFactory"), "create") self.assertEqual(expected, result)
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)
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)
def test_envPlaceholder(self): argument = PrimitiveArgument('ahoj %env(APP_ENV)%') self.assertEqual('\'ahoj \' + os.environ[\'APP_ENV\']', argument.getStringValue())
def test_valuePlaceholder(self): argument = PrimitiveArgument('ahoj %foo.bar%') self.assertEqual('\'ahoj \' + self.__parameters.foo.bar', argument.getStringValue())
def test_placeholderCombination(self): argument = PrimitiveArgument('ahoj %foo.bar% svete %env(APP_ENV)% novy') self.assertEqual('\'ahoj \' + self.__parameters.foo.bar + \' svete \' + os.environ[\'APP_ENV\'] + \' novy\'', argument.getStringValue())
def test_placeholderCombination2(self): argument = PrimitiveArgument('%foo.bar% svete %env(APP_ENV)%') self.assertEqual('self.__parameters.foo.bar + \' svete \' + os.environ[\'APP_ENV\']', argument.getStringValue())
def test_string(self): argument = PrimitiveArgument('hello world') self.assertEqual('\'hello world\'', argument.getStringValue())