def test_add_class_not_notifies_listeners_with_special_flag(
f_registry: Registry,
mocker: MockFixture,
) -> None:
listener = mocker.MagicMock()
f_registry.subscribe(listener)
f_registry.set(RegisterTestClass, notify_listeners=False)
assert not listener.notify.called
def get_object_by_registry_name(
self,
registry_name: str,
) -> Union[MessageConsumer, MessageProducer]:
registry = Registry(registry_name)
class_ = registry.get(self.object_type)
object_ = class_(**self.parameters)
return object_
def test_add_class_notifies_listeners(
f_registry: Registry,
mocker: MockFixture,
) -> None:
listeners = [mocker.MagicMock() for _ in range(2)]
[f_registry.subscribe(listener) for listener in listeners]
f_registry.set(RegisterTestClass)
assert all(listener.notify.called for listener in listeners)
def test_get_class_which_not_added_raises_error(
f_registry: Registry, ) -> None:
f_registry.set(RegisterTestClass)
with pytest.raises(
ItemNotExists,
match=(f'Avaliable keys: {RegisterTestClass.__name__}\n'
f'Requested key: unexpected_key'),
):
f_registry.get('unexpected_key')
def test_class_decorator() -> None:
@Registry.register('Test')
class RegisterTestClassDecorated:
pass
registry = Registry('Test')
assert registry.get(
RegisterTestClassDecorated.__name__) is RegisterTestClassDecorated
def test_save_object_add_it_to_registry(mocker: MockFixture, ) -> None:
registry = Registry(ABCCustomObjectModel.REGISTRY_NAME)
f_listeners = [mocker.MagicMock() for _ in range(2)]
[registry.subscribe(listener) for listener in f_listeners]
f_save = mocker.patch.object(Model, 'save')
custom_object = ABCCustomObjectModel()
custom_object.save()
f_save.assert_called_once()
assert str(custom_object) in registry.keys
[listener.notify.assert_called_once() for listener in f_listeners]
def _check_params_before_save(self) -> None:
class_ = Registry(self.REGISTRY_NAME).get(self.object_type)
if issubclass(class_, Validatable):
try:
class_.validate_params(self.parameters)
except Exception as e:
# TODO: Specify exceptions
# Now it masks exceptions of attributes of classes
required_fields = '\t\n'.join([
f'{name}:{type_}'
for name, type_ in class_.__annotations__.items()
], )
raise ValidationError(
f'Error: {e}\n'
f'Required fields for {self.object_type} is: \n'
f'\t{required_fields}', )
def notify(cls) -> None:
"""
Notification comes when registry updated (new custom object added)
"""
object_type = cls._meta.get_field('object_type')
object_type.choices = [(key, key)
for key in Registry(cls.REGISTRY_NAME).keys]
def ready(self) -> None:
if len(sys.argv) < 2 or sys.argv[1] in ('migrate', 'makemigrations'):
return
consumer_model = self.get_model('ConsumerModel')
Registry(CONSUMER_REGISTRY_NAME).subscribe(consumer_model)
consumer_model.CUSTOM_OBJECT_MODEL.upload_all_custom_objects_from_db_to_registry(
)
def test_upload_all_custom_objects_from_db_to_registry(
mocker: MockFixture, ) -> None:
f_objects_manager = mocker.MagicMock()
ABCCustomObjectModel.objects = f_objects_manager
f_custom_objects = [
ABCCustomObjectModel(name=f'custom_object_{i}') for i in range(2)
]
f_objects_manager.all.return_value = f_custom_objects
registry = Registry(ABCCustomObjectModel.REGISTRY_NAME)
f_listeners = [mocker.MagicMock() for _ in range(2)]
[registry.subscribe(listener) for listener in f_listeners]
ABCCustomObjectModel.upload_all_custom_objects_from_db_to_registry()
assert all(
str(custom_object) in registry.keys
for custom_object in f_custom_objects)
[listener.notify.assert_called_once() for listener in f_listeners]
def upload_all_custom_objects_from_db_to_registry(cls) -> None:
registry = Registry(cls.REGISTRY_NAME)
for object_ in cls.objects.all():
registry.set(
object_,
raise_if_exists=False,
notify_listeners=False,
)
registry.notify_all()
def _set_object(self, object_: 'ABCCustomObjectModel') -> None:
registry = Registry(self.REGISTRY_NAME)
registry.set(object_)
def f_registry() -> Registry:
Registry.clean()
return Registry('Test Registry')
def test_creating_same_registers_returns_same_register() -> None:
reg = Registry('Registry')
assert len(reg.keys) == 0
reg.set(RegisterTestClass)
reg1 = Registry('Registry')
assert RegisterTestClass.__name__ in reg1.keys
def test_add_class_to_registry(f_registry: Registry, ) -> None:
f_registry.set(RegisterTestClass)
assert f_registry.get(RegisterTestClass.__name__) == RegisterTestClass
assert list(f_registry.keys) == [RegisterTestClass.__name__]
def test_add_class_to_registry_twice_raises_error(
f_registry: Registry, ) -> None:
f_registry.set(RegisterTestClass)
with pytest.raises(ItemAlreadyExists):
f_registry.set(RegisterTestClass)
def test_add_class_to_registry_twice_not_raises_error_with_special_flag(
f_registry: Registry, ) -> None:
f_registry.set(RegisterTestClass)
f_registry.set(RegisterTestClass, raise_if_exists=False)
def test_create_two_different_registers() -> None:
Registry.clean()
reg1 = Registry('reg1')
reg1.set(RegisterTestClass)
reg2 = Registry('reg2')
reg2.set(RegisterTestClass)
assert list(Registry.get_registers()) == ['reg1', 'reg2']