def setUp(self) -> None: self.binding_registry = BindingRegistry() mock_binding = create_autospec(Binding, spec_set=True) mock_binding.target = FrozenTarget(MyType) self.my_type_binding = RegisteredBinding(mock_binding) mock_named_binding = create_autospec(Binding, spec_set=True) mock_named_binding.target = FrozenTarget(MyType, "my_name") self.my_type_named_binding = RegisteredBinding(mock_named_binding) self.my_type_binding_2 = RegisteredBinding( InstanceBinding(MyType, MyType())) other_mock_binding = create_autospec(Binding, spec_set=True) other_mock_binding.target = FrozenTarget(OtherType) self.other_type_binding = RegisteredBinding(other_mock_binding)
def setUp(self): self.binding_registry = BindingRegistry() self.binding_registry.register(RegisteredBinding(InstanceBinding(SingletonScope, SingletonScope()))) self.binding_registry.register(RegisteredBinding(InstanceBinding(ThreadScope, ThreadScope()))) self.adapter = MultiBindingToProviderAdapter( FromRegisteredBindingProviderFactory() ) self.my_instance = MyType() self.state = InjectionState( ProviderCreator(), self.binding_registry, ) self.context = InjectionContext(Target(List[MyType]), self.state)
def setUp(self) -> None: self.binding_registry = BindingRegistry() self.binding_registry.register(RegisteredBinding(InstanceBinding(SingletonScope, SingletonScope()))) self.provider_creator = ProviderCreator() self.state = InjectionState( self.provider_creator, self.binding_registry, ) self.context = InjectionContext(Target(MyType), self.state) self.other_context = InjectionContext(Target(MyOtherType), self.state) self.named_context = InjectionContext(Target(MyType, "my_name"), self.state) self.my_instance = MyType() self.my_instance_binding = InstanceBinding(MyType, self.my_instance) self.named_instance = MyType() self.my_named_instance_binding = InstanceBinding(MyType, self.named_instance, named="my_name") self.my_other_instance = MyOtherType() self.my_other_instance_binding = InstanceBinding(MyOtherType, self.my_other_instance)
class TestMultiBindingToProviderAdapter(unittest.TestCase): def setUp(self): self.binding_registry = BindingRegistry() self.binding_registry.register( RegisteredBinding(InstanceBinding(SingletonScope, SingletonScope()))) self.binding_registry.register( RegisteredBinding(InstanceBinding(ThreadScope, ThreadScope()))) self.adapter = MultiBindingToProviderAdapter( FromRegisteredBindingProviderFactory()) self.my_instance = MyType() self.state = InjectionState( ProviderCreator(), self.binding_registry, ) self.context = InjectionContext(Target(List[MyType]), self.state) def test_create_from_instance_binding(self): binding = RegisteredMultiBinding( MultiBinding(MyType, [ItemBinding(bound_instance=self.my_instance)]), item_bindings=[ RegisteredBinding(InstanceBinding(MyType, self.my_instance)) ]) provider = self.adapter.create(binding, self.context) list_instance = provider.get() self.assertEqual([self.my_instance], list_instance) def test_create_from_class_binding(self): binding = RegisteredMultiBinding( MultiBinding(MyType, [ItemBinding(bound_class=MyType)]), item_bindings=[RegisteredBinding(SelfBinding(MyType))]) provider = self.adapter.create(binding, self.context) list_instance = provider.get() self.assertEqual(1, len(list_instance)) self.assertIsInstance(list_instance[0], MyType) def test_create_from_provider_binding(self): provider = create_autospec(Provider, spec_set=True) instance = MyType() provider.get.return_value = instance binding = RegisteredMultiBinding( MultiBinding(MyType, [ItemBinding(bound_provider=provider)]), item_bindings=[ RegisteredBinding(ProviderBinding(MyType, provider)) ]) provider = self.adapter.create(binding, self.context) list_instance = provider.get() self.assertEqual([instance], list_instance) def test_create_scoped_provider(self): provider = self.adapter.create( RegisteredMultiBinding( MultiBinding(MyType, [ItemBinding(bound_class=MyType)], scope=ThreadScope), item_bindings=[ RegisteredBinding(SelfBinding(MyType, scope=ThreadScope)) ]), self.context) self.assertIsInstance(provider, ThreadScopedProvider) instance = provider.get() self.assertIsInstance(instance, list) self.assertEqual(1, len(instance)) self.assertIsInstance(instance[0], MyType) def test_non_injectable_scope_raises_exception(self): with self.assertRaises(NonInjectableTypeError): self.adapter.create( RegisteredMultiBinding( MultiBinding(MyType, [], scope=ImmediateScope)), self.context)
class TestProviderCreator(unittest.TestCase): def setUp(self) -> None: self.binding_registry = BindingRegistry() self.binding_registry.register(RegisteredBinding(InstanceBinding(SingletonScope, SingletonScope()))) self.provider_creator = ProviderCreator() self.state = InjectionState( self.provider_creator, self.binding_registry, ) self.context = InjectionContext(Target(MyType), self.state) self.other_context = InjectionContext(Target(MyOtherType), self.state) self.named_context = InjectionContext(Target(MyType, "my_name"), self.state) self.my_instance = MyType() self.my_instance_binding = InstanceBinding(MyType, self.my_instance) self.named_instance = MyType() self.my_named_instance_binding = InstanceBinding(MyType, self.named_instance, named="my_name") self.my_other_instance = MyOtherType() self.my_other_instance_binding = InstanceBinding(MyOtherType, self.my_other_instance) def test_get_provider_with_instance_bindings(self): self.binding_registry.register(RegisteredBinding(self.my_instance_binding)) self.binding_registry.register(RegisteredBinding(self.my_other_instance_binding)) provider = self.provider_creator.get_provider(self.context) self.assertIsInstance(provider, FromInstanceProvider) instance = provider.get() self.assertIsInstance(instance, MyType) provider = self.provider_creator.get_provider(self.other_context) self.assertIsInstance(provider, FromInstanceProvider) instance = provider.get() self.assertIsInstance(instance, MyOtherType) def test_get_provider_caches_providers(self): self.binding_registry.register(RegisteredBinding(self.my_instance_binding)) provider_1 = self.provider_creator.get_provider(self.context) provider_2 = self.provider_creator.get_provider(self.context) self.assertIs(provider_1, provider_2) def test_get_provider_with_named_bindings(self): self.binding_registry.register(RegisteredBinding(self.my_named_instance_binding)) with self.assertRaises(NoBindingFound): self.provider_creator.get_provider(self.context) provider = self.provider_creator.get_provider(self.named_context) self.assertIsInstance(provider, FromInstanceProvider) instance = provider.get() self.assertIs(self.named_instance, instance) def test_missing_binding_raises_exception(self): class MyParentClass: def __init__(self, my_param: MyType): self.my_param = my_param my_parent_binding = SelfBinding(MyParentClass) context = InjectionContext(Target(MyParentClass), self.state) self.binding_registry.register(RegisteredBinding(my_parent_binding)) with self.assertRaises(NonInjectableTypeError): self.provider_creator.get_provider(context) def test_list_binding_with_multi_binding(self): self.binding_registry.register( RegisteredMultiBinding( MultiBinding( MyType, [ ItemBinding(bound_instance=self.my_instance), ItemBinding(bound_class=MyType), ], ), item_bindings=[ RegisteredBinding(InstanceBinding(MyType, self.my_instance)), RegisteredBinding(SelfBinding(MyType)), ] ) ) context = InjectionContext(Target(List[MyType]), self.state) provider = self.provider_creator.get_provider(context) list_instance = provider.get() self.assertEqual([self.my_instance, ANY], list_instance) self.assertIsInstance(list_instance[1], MyType) def test_list_binding_with_named_arguments(self): self.binding_registry.register( RegisteredMultiBinding( MultiBinding( MyType, [ ItemBinding(bound_instance=self.named_instance), ], named="my_name", ), item_bindings=[ RegisteredBinding(InstanceBinding(MyType, self.named_instance, named="my_name")) ] ) ) self.binding_registry.register( RegisteredMultiBinding( MultiBinding( MyType, [ ItemBinding(bound_instance=self.my_instance), ], ), item_bindings=[ RegisteredBinding(InstanceBinding(MyType, self.my_instance)) ] ) ) self.binding_registry.register(RegisteredBinding(self.my_named_instance_binding)) self.binding_registry.register(RegisteredBinding(SelfBinding(MyType))) context = InjectionContext(Target(List[MyType], "my_name"), self.state) provider = self.provider_creator.get_provider(context) list_instance = provider.get() self.assertEqual([self.named_instance], list_instance) def test_set_binding_with_multi_binding(self): self.binding_registry.register( RegisteredMultiBinding( MultiBinding( MyType, [ ItemBinding(bound_instance=self.my_instance), ItemBinding(bound_class=MyType), ], ), item_bindings=[ RegisteredBinding(InstanceBinding(MyType, self.my_instance)), RegisteredBinding(SelfBinding(MyType)), ] ) ) context = InjectionContext(Target(Set[MyType]), self.state) provider = self.provider_creator.get_provider(context) self.assertIsInstance(provider, FromClassProvider) set_instance = provider.get() self.assertIn(self.my_instance, set_instance) self.assertEqual(2, len(set_instance)) def test_tuple_binding_with_multi_binding(self): self.binding_registry.register( RegisteredMultiBinding( MultiBinding( MyType, [ ItemBinding(bound_instance=self.my_instance), ItemBinding(bound_class=MyType), ], ), item_bindings=[ RegisteredBinding(InstanceBinding(MyType, self.my_instance)), RegisteredBinding(SelfBinding(MyType)), ] ) ) context = InjectionContext(Target(Tuple[MyType]), self.state) provider = self.provider_creator.get_provider(context) self.assertIsInstance(provider, FromClassProvider) tuple_instance = provider.get() self.assertEqual((self.my_instance, ANY), tuple_instance) self.assertIsInstance(tuple_instance[1], MyType) def test_optional_binding(self): self.binding_registry.register(RegisteredBinding(self.my_instance_binding)) context = InjectionContext(Target(Optional[MyType]), self.state) provider = self.provider_creator.get_provider(context) self.assertIsInstance(provider, FromInstanceProvider) instance = provider.get() self.assertIs(self.my_instance, instance) def test_type_binding(self): class SubType(MyType): pass self.binding_registry.register(RegisteredBinding(self.my_instance_binding)) self.binding_registry.register(RegisteredBinding(ClassBinding(MyType, SubType))) context = InjectionContext(Target(Type[MyType]), self.state) provider = self.provider_creator.get_provider(context) self.assertIsInstance(provider, FromInstanceProvider) instance = provider.get() self.assertIs(SubType, instance) def test_type_binding_with_explicit_binding(self): class SubType(MyType): pass self.binding_registry.register(RegisteredBinding(InstanceBinding(Type[MyType], MyType))) self.binding_registry.register(RegisteredBinding(ClassBinding(MyType, SubType))) context = InjectionContext(Target(Type[MyType]), self.state) provider = self.provider_creator.get_provider(context) self.assertIsInstance(provider, FromInstanceProvider) instance = provider.get() self.assertIs(MyType, instance) def test_type_binding_without_class_binding(self): class MyParentClass: def __init__(self, my_param: Type[MyType]): self.my_param = my_param parent_binding = SelfBinding(MyParentClass) self.binding_registry.register(RegisteredBinding(self.my_instance_binding)) self.binding_registry.register(RegisteredBinding(parent_binding)) context = InjectionContext(Target(Type[MyType]), self.state) with self.assertRaises(NonInjectableTypeError): self.provider_creator.get_provider(context) def test_provider_binding(self): class MyInjectee: pass class MyProvider(Provider[MyInjectee]): def __init__(self, my_param: MyType): self.my_param = my_param def get(self) -> MyInjectee: return MyInjectee() provider_binding = ProviderBinding(MyInjectee, MyProvider) self.binding_registry.register(RegisteredBinding(self.my_instance_binding)) self.binding_registry.register(RegisteredBinding(provider_binding)) context = InjectionContext(Target(MyInjectee), self.state) self.provider_creator.get_provider(context) def test_list_implicit_binding(self): instance = MyType() self.binding_registry.register(RegisteredBinding(InstanceBinding(MyType, instance))) context = InjectionContext(Target(List[MyType]), self.state) provider = self.provider_creator.get_provider(context) self.assertIsInstance(provider, ListProvider) list_instance = provider.get() self.assertEqual([instance], list_instance)
class TestBindingRegistry(unittest.TestCase): def setUp(self) -> None: self.binding_registry = BindingRegistry() mock_binding = create_autospec(Binding, spec_set=True) mock_binding.target = FrozenTarget(MyType) self.my_type_binding = RegisteredBinding(mock_binding) mock_named_binding = create_autospec(Binding, spec_set=True) mock_named_binding.target = FrozenTarget(MyType, "my_name") self.my_type_named_binding = RegisteredBinding(mock_named_binding) self.my_type_binding_2 = RegisteredBinding( InstanceBinding(MyType, MyType())) other_mock_binding = create_autospec(Binding, spec_set=True) other_mock_binding.target = FrozenTarget(OtherType) self.other_type_binding = RegisteredBinding(other_mock_binding) def test_register_saves_binding_to_new_type(self): self.binding_registry.register(self.my_type_binding) self.binding_registry.register(self.my_type_named_binding) self.binding_registry.register(self.other_type_binding) self.assertEqual( { FrozenTarget(MyType): self.my_type_binding, FrozenTarget(MyType, "my_name"): self.my_type_named_binding, FrozenTarget(OtherType): self.other_type_binding, }, self.binding_registry.get_bindings_by_target()) def test_register_multi_binding_saves_binding_to_known_type_in_order(self): item_binding_1 = ItemBinding(MyType) registered_item_binding_1 = RegisteredBinding(SelfBinding(MyType)) item_binding_2 = ItemBinding(bound_instance=MyType()) registered_item_binding_2 = RegisteredBinding( InstanceBinding(MyType, item_binding_2.bound_instance)) binding_1 = RegisteredMultiBinding(MultiBinding( MyType, [item_binding_1]), item_bindings=[ registered_item_binding_1, ]) binding_2 = RegisteredMultiBinding(MultiBinding( MyType, [item_binding_2], override_bindings=False), item_bindings=[ registered_item_binding_2, ]) self.binding_registry.register(binding_1) self.binding_registry.register(binding_2) registered_binding = self.binding_registry.get_binding( Target(List[MyType])) self.assertIsInstance(registered_binding, RegisteredMultiBinding) self.assertIsInstance(registered_binding.raw_binding, MultiBinding) self.assertEqual( [registered_item_binding_1, registered_item_binding_2], registered_binding.item_bindings) def test_register_multi_binding_with_override(self): item_binding_1 = ItemBinding(MyType) item_binding_2 = ItemBinding(bound_instance=MyType()) binding_1 = RegisteredMultiBinding( MultiBinding(MyType, [item_binding_1])) binding_2 = RegisteredMultiBinding( MultiBinding(MyType, [item_binding_2], override_bindings=True)) self.binding_registry.register(binding_1) self.binding_registry.register(binding_2) binding = self.binding_registry.get_binding(Target( List[MyType])).raw_binding self.assertIsInstance(binding, MultiBinding) self.assertEqual([item_binding_2], binding.item_bindings) def test_get_binding_returns_binding(self): self.binding_registry.register(self.my_type_binding) self.binding_registry.register(self.my_type_named_binding) self.binding_registry.register(self.my_type_binding_2) binding = self.binding_registry.get_binding(Target(MyType)) self.assertEqual(self.my_type_binding_2, binding) def test_get_binding_returns_named_binding(self): self.binding_registry.register(self.my_type_binding) self.binding_registry.register(self.my_type_named_binding) self.binding_registry.register(self.my_type_binding_2) binding = self.binding_registry.get_binding(Target(MyType, "my_name")) self.assertEqual(self.my_type_named_binding, binding) def test_get_binding_for_unknown_type_returns_none(self): binding = self.binding_registry.get_binding(Target(MyType)) self.assertIsNone(binding) def test_get_binding_from_string(self): self.binding_registry.register(self.my_type_binding) self.binding_registry.register(self.other_type_binding) binding = self.binding_registry.get_binding(Target("MyType")) self.assertEqual(self.my_type_binding, binding) def test_get_named_binding_from_string(self): self.binding_registry.register(self.my_type_binding) self.binding_registry.register(self.my_type_named_binding) self.binding_registry.register(self.other_type_binding) binding = self.binding_registry.get_binding(Target( "MyType", "my_name")) self.assertEqual(self.my_type_named_binding, binding) def test_get_binding_from_unknown_string(self): binding = self.binding_registry.get_binding(Target("MyUnknownType")) self.assertIsNone(binding) def test_get_binding_from_string_with_name_conflict_raises_exception(self): class MyNewType: pass binding_1 = create_autospec(Binding, spec_set=True) binding_1.target = FrozenTarget(MyNewType) # pylint: disable=function-redefined class MyNewType: pass binding_2 = create_autospec(Binding, spec_set=True) binding_2.target = FrozenTarget(MyNewType) self.binding_registry.register(RegisteredBinding(binding_1)) self.binding_registry.register(RegisteredBinding(binding_2)) with self.assertRaises(NonInjectableTypeError): self.binding_registry.get_binding(Target("MyNewType")) def test_register_provider_binding_with_instance_creates_additional_binding( self): class MyProvider(Provider[str]): def get(self) -> str: return "hello" provider_instance = MyProvider() provider_binding = RegisteredBinding( ProviderBinding(str, provider_instance, named="my_name")) self.binding_registry.register(provider_binding) self.assertEqual( { FrozenTarget(str, "my_name"): provider_binding, FrozenTarget(MyProvider, "my_name"): RegisteredBinding( InstanceBinding(MyProvider, provider_instance, "my_name")), }, self.binding_registry.get_bindings_by_target()) def test_register_provider_binding_with_class_creates_self_binding(self): class MyProvider(Provider[str]): def get(self) -> str: return "hello" provider_binding = RegisteredBinding( ProviderBinding(str, MyProvider, PerLookupScope, "my_name")) self.binding_registry.register(provider_binding) self.assertEqual( provider_binding, self.binding_registry.get_binding(Target(str, "my_name"))) provider_binding = self.binding_registry.get_binding( Target(MyProvider, "my_name")) self.assertIsInstance(provider_binding.raw_binding, SelfBinding) self.assertEqual(MyProvider, provider_binding.raw_binding.target_type) self.assertEqual(PerLookupScope, provider_binding.raw_binding.scope) def test_register_multi_binding_with_provider_binding_creates_self_binding( self): class MyProvider(Provider[str]): def get(self) -> str: return "hello" provider_binding = RegisteredBinding(ProviderBinding(str, MyProvider)) multi_binding = RegisteredMultiBinding( MultiBinding(str, [provider_binding.raw_binding]), item_bindings=[provider_binding]) self.binding_registry.register(multi_binding) provider_binding = self.binding_registry.get_binding( Target(MyProvider)) self.assertIsInstance(provider_binding.raw_binding, SelfBinding) self.assertEqual(MyProvider, provider_binding.raw_binding.target_type) def test_register_class_binding_creates_self_binding_if_target_does_not_exist( self): class MySubType(MyType): pass class_binding = RegisteredBinding(ClassBinding(MyType, MySubType)) self.binding_registry.register(class_binding) self.assertIs(class_binding, self.binding_registry.get_binding(Target(MyType))) self_binding = self.binding_registry.get_binding(Target(MySubType)) self.assertIsInstance(self_binding.raw_binding, SelfBinding) self.assertEqual(MySubType, self_binding.raw_binding.target_type) def test_register_class_binding_does_not_create_self_binding_if_target_exists( self): class MySubType(MyType): pass my_instance = MySubType() class_binding = RegisteredBinding(ClassBinding(MyType, MySubType)) instance_binding = RegisteredBinding( InstanceBinding(MySubType, my_instance)) self.binding_registry.register(instance_binding) self.binding_registry.register(class_binding) self.assertIs(class_binding, self.binding_registry.get_binding(Target(MyType))) self.assertIs(instance_binding, self.binding_registry.get_binding(Target(MySubType)))