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()
def test_formfield(): """Tests whether the :see:formfield function correctly returns a valid form.""" assert isinstance(LocalizedField().formfield(), LocalizedFieldForm) # case optional filling field = LocalizedField(blank=True, required=[]) assert not field.formfield().required for field in field.formfield().fields: assert not field.required # case required for any language field = LocalizedField(blank=False, required=[]) assert field.formfield().required for field in field.formfield().fields: assert not field.required # case required for specific languages required_langs = ['ro', 'nl'] field = LocalizedField(blank=False, required=required_langs) assert field.formfield().required for field in field.formfield().fields: if field.label in required_langs: assert field.required else: assert not field.required # case required for all languages field = LocalizedField(blank=False, required=True) assert field.formfield().required for field in field.formfield().fields: assert field.required
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 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 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, )
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" )
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 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, )
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') })
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 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 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=' ')
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 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'
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 setUpClass(cls): """Creates the test models in the database.""" super(LocalizedQuerySetTestCase, cls).setUpClass() cls.Model = get_fake_model({ 'title': LocalizedField(), })
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
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]
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 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", )
def setUpClass(cls): """Creates the test model in the database.""" super(LocalizedLookupsTestCase, cls).setUpClass() # reload app as setting has changed config = apps.get_app_config("localized_fields") config.ready() cls.TestModel = get_fake_model({"text": LocalizedField()})
class Country(models.Model): id = models.CharField(max_length=2, unique=True, primary_key=True) name = LocalizedField(_('name')) def __str__(self): return '%s: %s' % (self.id, self.name.en) class Meta: ordering = ('id', ) verbose_name_plural = "countries"