def removed_objects_with_ids_and_removed_related_object(
object_type, object_with_related_removed_ids, related_object_type, relation_name):
_factory = factories_registry.get_factory(object_type)
_related_factory = factories_registry.get_factory(related_object_type)
split_ids = object_with_related_removed_ids.split(',')
related_object = _related_factory.create(is_removed=True)
factory_kwargs = {'is_removed': True, relation_name: related_object}
for obj_id in split_ids:
factory_kwargs['pk'] = int(obj_id)
_factory.create(**factory_kwargs)
def removed_objects_with_ids(object_type, object_ids):
_factory = factories_registry.get_factory(object_type)
split_ids = object_ids.split(',')
for obj_id in split_ids:
instance = _factory(pk=int(obj_id))
instance.is_removed = True
instance.save()
def logged_user_type(context, user_type):
_factory = factories_registry.get_factory(user_type)
context.user = _factory(
email='{}@dane.gov.pl'.format(user_type.replace(' ', '_')),
password='******',
)
DjangoClient().force_login(context.user)
def admin_request_logged_user_is(admin_context, user_type):
_factory = factories_registry.get_factory(user_type)
assert _factory is not None
admin_context.admin.user = _factory.create(
email='{}@dane.gov.pl'.format(user_type.replace(' ', '_')),
password='******',
phone='0048123456789',
)
def object_type_created_with_params(context, object_type, params):
params = json.loads(params)
if object_type.endswith('report'):
_factory = factories_registry.get_factory(object_type)
return _factory.create(**params)
object_id = params.pop('id')
tags = params.pop('tags', [])
tag_factory = factories_registry.get_factory('tag')
_tags = []
for name in tags:
tag = tag_factory.create(name=name)
_tags.append(tag)
if _tags:
params['tags'] = _tags
if object_type == 'chart':
params['created_by'] = context.user
create_object(object_type, object_id, **params)
def create_object(obj_type, obj_id, is_removed=False, status='published', **kwargs):
_factory = factories_registry.get_factory(obj_type)
kwargs['pk'] = obj_id
if obj_type not in ['tag', 'task result']:
kwargs['is_removed'] = is_removed
if 'user' not in obj_type:
kwargs['status'] = status
return _factory(**kwargs)
def generic_user_with_data(object_type, user_data, context, admin_context):
assert object_type.endswith(
' user'), 'this keyword is only suited for creating users'
factory_ = factories_registry.get_factory(object_type)
if factory_ is None:
raise ValueError('invalid object type: %s' % object_type)
user_data = json.loads(user_data)
user = admin_context.admin.user = context.user = factory_(**user_data)
DjangoClient().force_login(user)
def logged_out_agent_user_created_with_params(context, params):
_factory = factories_registry.get_factory('agent user')
kwargs = {
'email': '*****@*****.**',
'password': '******',
}
kwargs.update(json.loads(params))
context.user = _factory(**kwargs)
DjangoClient().logout()
def changelist_for_object_type_is_requested(admin_context, object_type):
_factory = factories_registry.get_factory(object_type)
model = _factory._meta.model
client = Client()
client.force_login(admin_context.admin.user)
page_url = reverse(
f'admin:{model._meta.app_label}_{model._meta.model_name}_changelist')
response = client.get(page_url, follow=True)
admin_context.response = response
def also_x_subscriptions_of_random_factory(total, factory_name, context):
_factory = factories_registry.get_factory(factory_name)
instances = _factory.create_batch(total)
for instance in instances:
data = {
'object_name': instance._meta.object_name.lower(),
'object_ident': instance.id
}
SubscriptionFactory.create(user=context.user, data=data)
def logged_extra_agent_with_id_of_agent_with_id(context, extra_agent_id,
agent_id):
_agent_factory = factories_registry.get_factory('agent user')
_active_user_factory = factories_registry.get_factory('active user')
agent = _agent_factory(
id=agent_id,
email='*****@*****.**',
password='******',
)
user = _active_user_factory(
id=extra_agent_id,
email='*****@*****.**',
password='******',
)
user.extra_agent_of = agent
user.save()
context.user = user
DjangoClient().force_login(context.user)
def latest_object_attribute_is(obj_type, attr, value):
_factory = factories_registry.get_factory(obj_type)
model = _factory._meta.model
obj = model.raw.latest('id')
attr_val = getattr(obj, attr)
attr_val = str(attr_val) if not isinstance(attr_val, str) else attr_val
if value == 'not None':
assert attr_val is not None, f'{obj} attribute {attr} should not be None, but is {attr_val}'
else:
assert attr_val == value, f'{obj} attribute {attr} should be {value}, but is {attr_val}'
def fourth_subscription_with_id_of_an_factory(admin, s_id, object_type, f_id,
s_name, context):
_factory = factories_registry.get_factory(object_type)
model = _factory._meta.model
try:
instance = model.objects.get(pk=f_id)
except model.DoesNotExist:
instance = _factory(pk=f_id)
data = {
'name': s_name,
'object_name': object_type.lower(),
'object_ident': instance.id
}
SubscriptionFactory.create(user=context.user, data=data, force_id=s_id)
def subscription_with_id_of_removed_factory(admin, s_id, factory_name, f_id,
s_name, context):
_factory = factories_registry.get_factory(factory_name)
model = _factory._meta.model
try:
instance = model.objects.get(pk=f_id, is_removed=True)
except model.DoesNotExist:
instance = _factory(pk=f_id, is_removed=True)
data = {
'name': s_name,
'object_name': factory_name.lower(),
'object_ident': instance.id
}
with pytest.raises(SubscribedObjectDoesNotExist):
SubscriptionFactory.create(user=context.user, data=data, force_id=s_id)
def admin_user_runs_restore_action(admin_context, object_type,
requested_object_ids):
_factory = factories_registry.get_factory(object_type)
model = _factory._meta.model
client = Client()
client.force_login(admin_context.admin.user)
page_url = reverse(
f'admin:{model._meta.app_label}_{model.__name__}trash_changelist'.
lower())
data = {
'action': 'restore_objects',
'_selected_action': requested_object_ids.split(',')
}
response = client.post(page_url, data=data, follow=True)
admin_context.response = response
def object_type_has_trash_if(admin_context, object_type, has_trash):
has_trash = bool(int(has_trash))
_factory = factories_registry.get_factory(object_type)
model = _factory._meta.model
client = Client()
client.force_login(admin_context.admin.user)
try:
page_url = reverse(
f'admin:{model._meta.app_label}_{model._meta.model_name}trash_changelist'
)
response = client.get(page_url, follow=True)
assert has_trash
assert response.status_code == 200
except NoReverseMatch:
assert not has_trash
def create_subscription(user,
factory_name,
instance_id,
subscription_id,
subscription_name,
instance_removed=False,
instance_status='published'):
_factory = factories_registry.get_factory(factory_name)
instance = _factory(pk=instance_id,
is_removed=instance_removed,
status=instance_status)
data = {
'name': subscription_name,
'object_name': factory_name.lower(),
'object_ident': instance.id
}
return SubscriptionFactory.create(user=user,
data=data,
force_id=subscription_id)
def factory_get_or_create(object_type, params, is_removed=False):
kwargs = json.loads(params)
_factory = factories_registry.get_factory(object_type)
model = _factory._meta.model
is_model_soft_deletable = issubclass(model, SoftDeletableModel)
manager_name = 'objects'
if is_model_soft_deletable and is_removed:
manager_name = 'trash'
kwargs['is_removed'] = True
id_ = kwargs.get('id')
proxy_model = make_proxy_model(model)
qs = proxy_model.objects.filter(id=id_)
if qs.exists():
if is_model_soft_deletable:
qs.update(is_removed=is_removed, is_permanently_removed=False)
instance = getattr(model, manager_name).get(id=id_)
else:
instance = _factory(**kwargs)
instance.save()
return instance
def admin_request_logged_user_with_id(admin_context, user_type, user_params):
_factory = factories_registry.get_factory(user_type)
assert _factory is not None
data = json.loads(user_params)
admin_context.admin.user = _factory(**data)
def publish_object_with_id_999(object_type):
_factory = factories_registry.get_factory(object_type)
instance = _factory(pk=999)
instance.status = 'published'
instance.save()
def draft_object_with_id_999(object_type):
_factory = factories_registry.get_factory(object_type)
instance = _factory(pk=999)
instance.status = 'draft'
instance.save()
def objects_with_ids_are_still_in_trash(object_type, unrestored_object_ids):
_factory = factories_registry.get_factory(object_type)
ids_list = unrestored_object_ids.split(',')
model = _factory._meta.model
assert model.raw.filter(pk__in=ids_list,
is_removed=True).count() == len(ids_list)
def objects_with_ids_are_restored_from_trash(object_type, restored_object_ids):
_factory = factories_registry.get_factory(object_type)
model = _factory._meta.model
ids_list = restored_object_ids.split(',')
assert model.objects.filter(pk__in=ids_list,
is_removed=False).count() == len(ids_list)
def remove_object_with_id_pp(object_type, object_id):
_factory = factories_registry.get_factory(object_type)
model = _factory._meta.model
instance = model.objects.get(pk=object_id)
instance.is_removed = True
instance.save()
def restore_object_with_id_p(object_type, object_id):
_factory = factories_registry.get_factory(object_type)
model = _factory._meta.model
instance = model.raw.get(pk=object_id)
instance.is_removed = False
instance.save()
def six_articles_p(object_type):
_factory = factories_registry.get_factory(object_type)
return _factory.create_batch(6)
def active_datasource_by_type_for_data(datasource_type, obj_id, data_str):
_factory = factories_registry.get_factory(datasource_type)
data = json.loads(data_str)
data['status'] = 'active'
data['id'] = obj_id
return _factory.create(**data)
def attr_to_object_with_id_ppp(attr_name, attr_value, object_type, object_id):
_factory = factories_registry.get_factory(object_type)
instance = _factory._meta.model.objects.get(pk=object_id)
setattr(instance, attr_name, attr_value)
instance.save()
