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)