def test_populate_multiple_from_fields_fk():
"""Tests whether populating the slug from multiple fields works
correctly."""
model_fk = get_fake_model({"name": LocalizedField()})
model = get_fake_model({
"title":
LocalizedField(),
"other":
models.ForeignKey(model_fk, on_delete=models.CASCADE),
"slug":
LocalizedUniqueSlugField(populate_from=("title", "other.name")),
})
other = model_fk.objects.create(name={settings.LANGUAGE_CODE: "swen"})
obj = model()
for lang_code, lang_name in settings.LANGUAGES:
obj.other_id = other.id
obj.title.set(lang_code, "title %s" % lang_name)
obj.save()
for lang_code, lang_name in settings.LANGUAGES:
assert (obj.slug.get(lang_code) == "title-%s-swen" %
lang_name.lower())
def test_populate_multiple_from_fields_fk():
"""Tests whether populating the slug from multiple
fields works correctly."""
model_fk = get_fake_model(
{
'name': LocalizedField(),
}
)
model = get_fake_model(
{
'title': LocalizedField(),
'other': models.ForeignKey(model_fk, on_delete=models.CASCADE),
'slug': LocalizedUniqueSlugField(populate_from=('title', 'other.name'))
}
)
other = model_fk.objects.create(name={settings.LANGUAGE_CODE: 'swen'})
obj = model()
for lang_code, lang_name in settings.LANGUAGES:
obj.other_id = other.id
obj.title.set(lang_code, 'title %s' % lang_name)
obj.save()
for lang_code, lang_name in settings.LANGUAGES:
assert obj.slug.get(lang_code) == 'title-%s-swen' % lang_name.lower()
class Form(SlugModel):
name = LocalizedField(blank=False, null=False, required=False)
description = LocalizedField(blank=True, null=True, required=False)
meta = JSONField(default=dict)
is_published = models.BooleanField(default=False)
is_archived = models.BooleanField(default=False)
questions = models.ManyToManyField("Question",
through="FormQuestion",
related_name="forms")
source = models.ForeignKey(
"self",
blank=True,
null=True,
help_text="Reference this form has been copied from",
related_name="+",
on_delete=models.SET_NULL,
)
def all_questions(self):
questions = self.questions.all()
for q in self.questions.filter(type=Question.TYPE_FORM):
questions = questions.union(q.sub_form.all_questions())
return questions
class Meta:
indexes = [GinIndex(fields=["meta"])]
class Workflow(SlugModel):
name = LocalizedField(blank=False, null=False, required=False)
description = LocalizedField(blank=True, null=True, required=False)
meta = models.JSONField(default=dict)
is_published = models.BooleanField(default=False)
is_archived = models.BooleanField(default=False)
start_tasks = models.ManyToManyField(
Task, related_name="+", help_text="Starting task(s) of the workflow."
)
allow_all_forms = models.BooleanField(
default=False, help_text="Allow workflow to be started with any form"
)
allow_forms = models.ManyToManyField(
"caluma_form.Form",
help_text="List of forms which are allowed to start workflow with",
related_name="workflows",
blank=True,
)
@property
def flows(self):
return Flow.objects.filter(pk__in=self.task_flows.values("flow"))
class Meta:
indexes = [GinIndex(fields=["meta"])]
class Task(SlugModel):
TYPE_SIMPLE = "simple"
TYPE_COMPLETE_WORKFLOW_FORM = "complete_workflow_form"
TYPE_COMPLETE_TASK_FORM = "complete_task_form"
TYPE_CHOICES = (TYPE_SIMPLE, TYPE_COMPLETE_WORKFLOW_FORM, TYPE_COMPLETE_TASK_FORM)
TYPE_CHOICES_TUPLE = (
(TYPE_SIMPLE, "Task which can only be marked as completed."),
(TYPE_COMPLETE_WORKFLOW_FORM, "Task completing defined workflow form."),
(TYPE_COMPLETE_TASK_FORM, "Task completing defined task form."),
)
name = LocalizedField(blank=False, null=False, required=False)
description = LocalizedField(blank=True, null=True, required=False)
type = models.CharField(choices=TYPE_CHOICES_TUPLE, max_length=50)
meta = JSONField(default=dict)
address_groups = models.TextField(
blank=True,
null=True,
help_text="Group jexl returning what group(s) derived work items will be addressed to.",
)
is_archived = models.BooleanField(default=False)
form = models.ForeignKey(
"form.Form",
on_delete=models.DO_NOTHING,
related_name="tasks",
blank=True,
null=True,
)
def test_from_db_value_none():
"""Tests whether the :see:from_db_value function
correctly handles None values."""
localized_value = LocalizedField().from_db_value(None)
for lang_code, _ in settings.LANGUAGES:
assert localized_value.get(lang_code) is None
def test_to_python():
"""Tests whether the :see:to_python function
produces the expected :see:LocalizedValue."""
input_data = get_init_values()
localized_value = LocalizedField().to_python(input_data)
for language, value in input_data.items():
assert localized_value.get(language) == value
class Form(SlugModel):
name = LocalizedField(blank=False, null=False, required=False)
description = LocalizedField(blank=True, null=True, required=False)
meta = JSONField(default={})
is_published = models.BooleanField(default=False)
is_archived = models.BooleanField(default=False)
questions = models.ManyToManyField(
"Question", through="FormQuestion", related_name="forms"
)
def test_to_python_non_dict():
"""Tests whether the :see:to_python function produces the expected
:see:LocalizedValue when it is passed a non-dictionary value."""
localized_value = LocalizedField().to_python(list())
assert localized_value
for lang_code, _ in settings.LANGUAGES:
assert localized_value.get(lang_code) is None
class Task(SlugModel):
TYPE_SIMPLE = "simple"
TYPE_COMPLETE_WORKFLOW_FORM = "complete_workflow_form"
TYPE_COMPLETE_TASK_FORM = "complete_task_form"
TYPE_CHOICES = (TYPE_SIMPLE, TYPE_COMPLETE_WORKFLOW_FORM,
TYPE_COMPLETE_TASK_FORM)
TYPE_CHOICES_TUPLE = (
(TYPE_SIMPLE, "Task which can simply be marked as completed."),
(TYPE_COMPLETE_WORKFLOW_FORM,
"Task to complete a defined workflow form."),
(TYPE_COMPLETE_TASK_FORM, "Task to complete a defined task form."),
)
name = LocalizedField(blank=False, null=False, required=False)
description = LocalizedField(blank=True, null=True, required=False)
type = ChoicesCharField(choices=TYPE_CHOICES_TUPLE, max_length=50)
meta = JSONField(default=dict)
address_groups = models.TextField(
blank=True,
null=True,
help_text=
"Group jexl returning what group(s) derived work items will be addressed to.",
)
control_groups = models.TextField(
blank=True,
null=True,
help_text=
"Group jexl returning what group(s) derived work items will be assigned to for controlling.",
)
is_archived = models.BooleanField(default=False)
form = models.ForeignKey(
"caluma_form.Form",
on_delete=models.DO_NOTHING,
related_name="tasks",
blank=True,
null=True,
)
lead_time = models.PositiveIntegerField(
blank=True,
null=True,
help_text="Time in seconds task may take to be processed.",
)
is_multiple_instance = models.BooleanField(
default=False,
help_text=
"Allows creating multiple work items for this task using the `CreateWorkItem` mutation. If true, one work item will be created for each entry in `address_groups`.",
)
def calculate_deadline(self):
if self.lead_time is not None:
return timezone.now() + timedelta(seconds=self.lead_time)
return None
class Meta:
indexes = [GinIndex(fields=["meta"])]
class Task(SlugModel):
TYPE_SIMPLE = "simple"
TYPE_CHOICES = (TYPE_SIMPLE,)
TYPE_CHOICES_TUPLE = ((TYPE_SIMPLE, "Task which can only be marked as completed."),)
name = LocalizedField(blank=False, null=False, required=False)
description = LocalizedField(blank=True, null=True, required=False)
type = models.CharField(choices=TYPE_CHOICES_TUPLE, max_length=50)
meta = JSONField(default={})
is_archived = models.BooleanField(default=False)
def test_to_python_str():
"""Tests whether the :see:to_python function produces the expected
:see:LocalizedValue when it is passed serialized string value."""
serialized_str = json.dumps(get_init_values())
localized_value = LocalizedField().to_python(serialized_str)
assert isinstance(localized_value, LocalizedValue)
for language, value in get_init_values().items():
assert localized_value.get(language) == value
assert getattr(localized_value, language) == value
def test_get_prep_value():
""""Tests whether the :see:get_prep_value function
produces the expected dictionary."""
input_data = get_init_values()
localized_value = LocalizedValue(input_data)
output_data = LocalizedField().get_prep_value(localized_value)
for language, value in input_data.items():
assert language in output_data
assert output_data.get(language) == value
def setUpClass(cls):
"""Creates the test model in the database."""
super(LocalizedFieldsAdminMixinTestCase, cls).setUpClass()
cls.TestRelModel = get_fake_model({'description': LocalizedField()})
cls.TestModel = get_fake_model({
'title':
LocalizedField(),
'rel':
models.ForeignKey(cls.TestRelModel, on_delete=models.CASCADE)
})
def test_get_prep_value_clean(self):
"""Tests whether the :see:get_prep_value produces
None as the output when it is passed an empty, but
valid LocalizedValue value but, only when null=True."""
localized_value = LocalizedValue()
with self.assertRaises(IntegrityError):
LocalizedField(null=False).get_prep_value(localized_value)
assert not LocalizedField(null=True).get_prep_value(localized_value)
assert not LocalizedField().clean(None)
assert not LocalizedField().clean(['huh'])
class Workflow(SlugModel):
name = LocalizedField(blank=False, null=False, required=False)
description = LocalizedField(blank=True, null=True, required=False)
meta = JSONField(default={})
is_published = models.BooleanField(default=False)
is_archived = models.BooleanField(default=False)
start = models.ForeignKey(Task, on_delete=models.CASCADE, related_name="+")
form = models.ForeignKey(
"form.Form",
on_delete=models.DO_NOTHING,
related_name="workflows",
blank=True,
null=True,
)
class Form(SlugModel):
name = LocalizedField(blank=False, null=False, required=False)
description = LocalizedField(blank=True, null=True, required=False)
meta = JSONField(default=dict)
is_published = models.BooleanField(default=False)
is_archived = models.BooleanField(default=False)
questions = models.ManyToManyField(
"Question", through="FormQuestion", related_name="forms"
)
source = models.ForeignKey(
"self",
blank=True,
null=True,
help_text="Reference this form has been copied from",
related_name="+",
)
def setUpClass(cls):
"""Creates the test model in the database."""
super(LocalizedModelTestCase, cls).setUpClass()
cls.TestModel = get_fake_model('LocalizedModelTestCase',
{'title': LocalizedField()})
def test_required_all(self):
"""Tests whether passing required=True properly validates
that all languages are filled in."""
model = get_fake_model(dict(title=LocalizedField(required=True)))
with self.assertRaises(IntegrityError):
model.objects.create(title=dict(ro='romanian', nl='dutch'))
with self.assertRaises(IntegrityError):
model.objects.create(title=dict(nl='dutch'))
with self.assertRaises(IntegrityError):
model.objects.create(title=dict(random='random'))
with self.assertRaises(IntegrityError):
model.objects.create(title=dict())
with self.assertRaises(IntegrityError):
model.objects.create(title=None)
with self.assertRaises(IntegrityError):
model.objects.create(title='')
with self.assertRaises(IntegrityError):
model.objects.create(title=' ')
def test_required_some(self):
"""Tests whether passing an array to required,
properly validates whether the specified languages
are marked as required."""
model = get_fake_model(
dict(title=LocalizedField(required=['nl', 'ro'])))
with self.assertRaises(IntegrityError):
model.objects.create(title=dict(ro='romanian', nl='dutch'))
with self.assertRaises(IntegrityError):
model.objects.create(title=dict(nl='dutch'))
with self.assertRaises(IntegrityError):
model.objects.create(title=dict(random='random'))
with self.assertRaises(IntegrityError):
model.objects.create(title=dict())
with self.assertRaises(IntegrityError):
model.objects.create(title=None)
with self.assertRaises(IntegrityError):
model.objects.create(title='')
with self.assertRaises(IntegrityError):
model.objects.create(title=' ')
def test_get_prep_value_no_localized_value():
"""Tests whether the :see:get_prep_value function
produces the expected output when it is passed a
non-LocalizedValue value."""
output_data = LocalizedField().get_prep_value(['huh'])
assert not output_data
def setUpClass(cls):
"""Creates the test models in the database."""
super(LocalizedSlugFieldTestCase, cls).setUpClass()
cls.AutoSlugModel = get_fake_model(
'LocalizedAutoSlugFieldTestModel', {
'title': LocalizedField(),
'slug': LocalizedAutoSlugField(populate_from='title')
})
cls.MagicSlugModel = get_fake_model(
'LocalizedUniqueSlugFieldTestModel', {
'title': LocalizedField(),
'slug': LocalizedUniqueSlugField(populate_from='title')
})
def test_uniue_slug_no_change(cls):
"""Tests whether slugs are not re-generated if not needed."""
NoChangeSlugModel = get_fake_model(
'NoChangeSlugModel', {
'title':
LocalizedField(),
'slug':
LocalizedUniqueSlugField(populate_from='title',
include_time=True)
})
title = 'myuniquetitle'
obj = NoChangeSlugModel()
obj.title.en = title
obj.title.nl = title
obj.save()
old_slug_en = copy.deepcopy(obj.slug.en)
old_slug_nl = copy.deepcopy(obj.slug.nl)
obj.title.nl += 'beer'
obj.save()
assert old_slug_en == obj.slug.en
assert old_slug_nl != obj.slug.nl
def test_from_db_value_none_return_none(self):
"""Tests whether the :see:from_db_value function correctly handles None
values when LOCALIZED_FIELDS_EXPERIMENTAL is set to True."""
with self.settings(LOCALIZED_FIELDS_EXPERIMENTAL=True):
localized_value = LocalizedField.from_db_value(None)
assert localized_value is None
def test_init():
"""Tests whether the :see:__init__ function
correctly handles parameters"""
field = LocalizedField(blank=True)
assert field.required == []
field = LocalizedField(blank=False)
assert field.required == [settings.LANGUAGE_CODE]
field = LocalizedField(required=True)
assert field.required == [
lang_code for lang_code, _ in settings.LANGUAGES
]
field = LocalizedField(required=False)
assert field.required == []
def test_descriptor_user_defined_primary_key(self):
"""Tests that descriptor works even when primary key is user defined."""
model = get_fake_model(
dict(slug=models.SlugField(primary_key=True),
title=LocalizedField()))
obj = model.objects.create(slug='test', title='test')
assert obj.title == 'test'
class DynamicOption(core_models.UUIDModel):
slug = models.CharField(max_length=255)
label = LocalizedField(blank=False, null=False, required=False)
document = models.ForeignKey("Document", on_delete=models.CASCADE)
question = models.ForeignKey("Question", on_delete=models.CASCADE)
class Meta:
unique_together = ("slug", "document", "question")
def setUpClass(cls):
"""Creates the test models in the database."""
super(LocalizedQuerySetTestCase, cls).setUpClass()
cls.Model = get_fake_model({
'title': LocalizedField(),
})
def test_from_db_value():
"""Tests whether the :see:from_db_value function
produces the expected :see:LocalizedValue."""
input_data = get_init_values()
localized_value = LocalizedField().from_db_value(input_data)
for lang_code, _ in settings.LANGUAGES:
assert getattr(localized_value, lang_code) == input_data[lang_code]
class Option(SlugModel):
label = LocalizedField(blank=False, null=False, required=False)
meta = JSONField(default=dict)
source = models.ForeignKey(
"self",
blank=True,
null=True,
related_name="+",
help_text="Reference this option has been copied from",
)
