mirror of
https://github.com/SectorLabs/django-localized-fields.git
synced 2025-04-24 19:32:53 +03:00
276 lines
9.2 KiB
Python
276 lines
9.2 KiB
Python
import json
|
|
|
|
from django.conf import settings
|
|
from django.db import models
|
|
from django.db.utils import IntegrityError
|
|
from django.test import TestCase
|
|
|
|
from localized_fields.fields import LocalizedField
|
|
from localized_fields.forms import LocalizedFieldForm
|
|
from localized_fields.value import LocalizedValue
|
|
|
|
from .data import get_init_values
|
|
from .fake_model import get_fake_model
|
|
|
|
|
|
class LocalizedFieldTestCase(TestCase):
|
|
"""Tests the :see:LocalizedField class."""
|
|
|
|
@staticmethod
|
|
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 == []
|
|
|
|
@staticmethod
|
|
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]
|
|
|
|
@staticmethod
|
|
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_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
|
|
|
|
@staticmethod
|
|
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
|
|
|
|
@staticmethod
|
|
def test_to_python_non_json():
|
|
"""Tests whether the :see:to_python function
|
|
properly handles a string that is not JSON."""
|
|
|
|
localized_value = LocalizedField().to_python('my value')
|
|
assert localized_value.get() == 'my value'
|
|
|
|
@staticmethod
|
|
def test_to_python_none():
|
|
"""Tests whether the :see:to_python function
|
|
produces the expected :see:LocalizedValue
|
|
instance when it is passes None."""
|
|
|
|
localized_value = LocalizedField().to_python(None)
|
|
assert localized_value
|
|
|
|
for lang_code, _ in settings.LANGUAGES:
|
|
assert localized_value.get(lang_code) is None
|
|
|
|
@staticmethod
|
|
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
|
|
|
|
@staticmethod
|
|
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
|
|
|
|
@staticmethod
|
|
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
|
|
|
|
@staticmethod
|
|
def test_get_prep_value_none():
|
|
"""Tests whether the :see:get_prep_value function
|
|
produces the expected output when it is passed None."""
|
|
|
|
output_data = LocalizedField().get_prep_value(None)
|
|
assert not output_data
|
|
|
|
@staticmethod
|
|
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 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'])
|
|
|
|
@staticmethod
|
|
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
|
|
|
|
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_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=' ')
|