def test_str_fallback():
"""Tests whether the :see:LocalizedValue
class's __str__'s fallback functionality
works properly."""
test_value = 'myvalue'
localized_value = LocalizedValue({settings.LANGUAGE_CODE: test_value})
other_language = settings.LANGUAGES[-1][0]
# make sure that, by default it returns
# the value in the default language
assert str(localized_value) == test_value
# make sure that it falls back to the
# primary language when there's no value
# available in the current language
translation.activate(other_language)
assert str(localized_value) == test_value
# make sure that it's just __str__ falling
# back and that for the other language
# there's no actual value
assert localized_value.get(other_language) != test_value
def get_format_validators(include=None, dic=False):
"""Get all FormatValidators.
:param include: List of FormatValidators to include
:param dic: Should return a dict
:return: List of FormatValidator-objects if dic False otherwise dict
"""
format_validator_classes = [
import_string(cls) for cls in settings.FORMAT_VALIDATOR_CLASSES
] + base_format_validators
if include is not None:
format_validator_classes = [
fvc for fvc in format_validator_classes if fvc.slug in include
]
if dic:
return {ds.slug: ds for ds in format_validator_classes}
return [
FormatValidator(
slug=ds.slug,
name=LocalizedValue(ds.name).translate(),
regex=ds.regex,
error_msg=LocalizedValue(ds.error_msg).translate(),
) for ds in format_validator_classes
]
def test_get_explicit():
"""Tests whether the the :see:LocalizedValue class's :see:get function
works properly when specifying an explicit value."""
keys = get_init_values()
localized_value = LocalizedValue(keys)
for language, value in keys.items():
assert localized_value.get(language) == value
def _get_test_value():
"""Gets a :see:LocalizedValue instance for testing."""
value = LocalizedValue()
for lang_code, lang_name in settings.LANGUAGES:
value.set(lang_code, "<script>%s</script>" % lang_name)
return value
def test_get_default_language():
"""Tests whether the :see:LocalizedValue class's see:get function
properly gets the value in the default language."""
keys = get_init_values()
localized_value = LocalizedValue(keys)
for language, _ in keys.items():
translation.activate(language)
assert localized_value.get() == keys[settings.LANGUAGE_CODE]
def test_deconstruct():
"""Tests whether the :see:LocalizedValue class's :see:deconstruct
function works properly."""
keys = get_init_values()
value = LocalizedValue(keys)
path, args, kwargs = value.deconstruct()
assert args[0] == keys
def test_translate_custom_language():
"""Tests whether the :see:LocalizedValue class's translate() ignores
the active language when one is specified explicitely."""
localized_value = LocalizedValue(
{settings.LANGUAGE_CODE: settings.LANGUAGE_CODE, "ro": "ro"}
)
with translation.override("en"):
assert localized_value.translate("ro") == "ro"
def test_translate():
"""Tests whether the :see:LocalizedValue class's __str__ works
properly."""
keys = get_init_values()
localized_value = LocalizedValue(keys)
for language, value in keys.items():
translation.activate(language)
assert localized_value.translate() == value
def test_init_array():
"""Tests whether the __init__ function of :see:LocalizedValue properly
handles an array.
Arrays can be passed to LocalizedValue as a result of a ArrayAgg
operation.
"""
value = LocalizedValue(["my value"])
assert value.get(settings.LANGUAGE_CODE) == "my value"
def test_set():
"""Tests whether the :see:LocalizedValue class's see:set function works
properly."""
localized_value = LocalizedValue()
for language, value in get_init_values():
localized_value.set(language, value)
assert localized_value.get(language) == value
assert getattr(localized_value, language) == value
def test_eq():
"""Tests whether the __eq__ operator of :see:LocalizedValue works
properly."""
a = LocalizedValue({"en": "a", "ar": "b"})
b = LocalizedValue({"en": "a", "ar": "b"})
assert a == b
b.en = "b"
assert a != b
def test_eq():
"""Tests whether the __eq__ operator
of :see:LocalizedValue works properly."""
a = LocalizedValue({'en': 'a', 'ar': 'b'})
b = LocalizedValue({'en': 'a', 'ar': 'b'})
assert a == b
b.en = 'b'
assert a != b
def load(self):
if is_iterable_and_no_string(self.data):
if not 0 < len(self.data) < 3:
raise DataSourceException(
f"Failed to parse data:\n{self.data}")
elif len(self.data) == 1:
return str(self.data[0]), str(self.data[0])
elif isinstance(self.data[1], dict):
label = LocalizedValue(self.data[1])
return (str(self.data[0]), str(label.translate()))
return str(self.data[0]), str(self.data[1])
return str(self.data), str(self.data)
def test_translate_fallback_custom_fallback():
"""Tests whether the :see:LocalizedValue class's translate()'s fallback
functionality properly respects the LOCALIZED_FIELDS_FALLBACKS
setting."""
fallbacks = {"nl": ["ro"]}
localized_value = LocalizedValue(
{settings.LANGUAGE_CODE: settings.LANGUAGE_CODE, "ro": "ro"}
)
with override_settings(LOCALIZED_FIELDS_FALLBACKS=fallbacks):
with translation.override("nl"):
assert localized_value.translate() == "ro"
def test_decompress():
"""Tests whether a :see:LocalizedValue instance
can correctly be "decompressed" over the available
widgets."""
localized_value = LocalizedValue()
for lang_code, lang_name in settings.LANGUAGES:
localized_value.set(lang_code, lang_name)
widget = LocalizedFieldWidget()
decompressed_values = widget.decompress(localized_value)
for (lang_code, _), value in zip(settings.LANGUAGES, decompressed_values):
assert localized_value.get(lang_code) == value
def test_get_prep_value():
"""Tests whether the :see:get_prep_value function returns correctly
value."""
value = LocalizedValue({"en": None})
assert LocalizedFileField().get_prep_value(None) is None
assert isinstance(LocalizedFileField().get_prep_value(value), dict)
assert LocalizedFileField().get_prep_value(value)["en"] == ""
def test_init_default_values():
"""Tests whether the __init__ function of the :see:LocalizedValue
accepts the default value or an empty dict properly."""
value = LocalizedValue()
for lang_code, _ in settings.LANGUAGES:
assert getattr(value, lang_code) is None
def test_init():
"""Tests whether the __init__ function of the :see:LocalizedValue class
works as expected."""
keys = get_init_values()
value = LocalizedValue(keys)
for lang_code, _ in settings.LANGUAGES:
assert getattr(value, lang_code, None) == keys[lang_code]
def test_get_context_required():
"""Tests whether the :see:get_context correctly
handles 'required' attribute, separately for each subwidget."""
widget = LocalizedFieldWidget()
widget.widgets[0].is_required = True
widget.widgets[1].is_required = False
context = widget.get_context(name='test', value=LocalizedValue(),
attrs=dict(required=True))
assert context['widget']['subwidgets'][0]['attrs']['required']
assert 'required' not in context['widget']['subwidgets'][1]['attrs']
def test_get_context_required():
"""Tests whether the :see:get_context correctly handles 'required'
attribute, separately for each subwidget."""
widget = LocalizedFieldWidget()
widget.widgets[0].is_required = True
widget.widgets[1].is_required = False
context = widget.get_context(
name="test", value=LocalizedValue(), attrs=dict(required=True)
)
assert context["widget"]["subwidgets"][0]["attrs"]["required"]
assert "required" not in context["widget"]["subwidgets"][1]["attrs"]
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 test_get_context_langs():
"""Tests whether the :see:get_context contains 'lang_code' and
'lang_name' attribute for each subwidget."""
widget = LocalizedFieldWidget()
context = widget.get_context(name='test', value=LocalizedValue(),
attrs=dict())
subwidgets_context = context['widget']['subwidgets']
for widget, context in zip(widget.widgets, subwidgets_context):
assert 'lang_code' in context
assert 'lang_name' in context
assert widget.lang_code == context['lang_code']
assert widget.lang_name == context['lang_name']
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'])
def test_get_context_langs():
"""Tests whether the :see:get_context contains 'lang_code' and
'lang_name' attribute for each subwidget."""
widget = LocalizedFieldWidget()
context = widget.get_context(
name="test", value=LocalizedValue(), attrs=dict()
)
subwidgets_context = context["widget"]["subwidgets"]
for widget, context in zip(widget.widgets, subwidgets_context):
assert "lang_code" in context
assert "lang_name" in context
assert widget.lang_code == context["lang_code"]
assert widget.lang_name == context["lang_name"]
def test_str_fallback_custom_fallback():
"""Tests whether the :see:LocalizedValue class's
__str__'s fallback functionality properly respects
the LOCALIZED_FIELDS_FALLBACKS setting."""
settings.LOCALIZED_FIELDS_FALLBACKS = {'nl': ['ro']}
localized_value = LocalizedValue({
settings.LANGUAGE_CODE: settings.LANGUAGE_CODE,
'ro': 'ro'
})
with translation.override('nl'):
assert str(localized_value) == 'ro'
def test_localized_ref(cls):
"""Tests whether the :see:LocalizedRef expression properly works."""
obj = cls.TestModel1.objects.create(name="bla bla")
for i in range(0, 10):
cls.TestModel2.objects.create(
text=LocalizedValue(
dict(
en="text_%d_en" % i,
ro="text_%d_ro" % i,
nl="text_%d_nl" % i,
)),
other=obj,
)
def create_queryset(ref):
return cls.TestModel1.objects.annotate(mytexts=ref).values_list(
"mytexts", flat=True)
# assert that it properly selects the currently active language
for lang_code, _ in settings.LANGUAGES:
translation.activate(lang_code)
queryset = create_queryset(LocalizedRef("features__text"))
for index, value in enumerate(queryset):
assert translation.get_language() in value
assert str(index) in value
# ensure that the default language is used in case no
# language is active at all
translation.deactivate_all()
queryset = create_queryset(LocalizedRef("features__text"))
for index, value in enumerate(queryset):
assert settings.LANGUAGE_CODE in value
assert str(index) in value
# ensures that overriding the language works properly
queryset = create_queryset(LocalizedRef("features__text", "ro"))
for index, value in enumerate(queryset):
assert "ro" in value
assert str(index) in value
# ensures that using this in combination with ArrayAgg works properly
queryset = create_queryset(
ArrayAgg(LocalizedRef("features__text", "ro"))).first()
assert isinstance(queryset, list)
for value in queryset:
assert "ro" in value
def test_localized_lookup(self):
"""Tests whether localized lookup properly works."""
self.TestModel.objects.create(text=LocalizedValue(
dict(en='text_en', ro='text_ro', nl='text_nl')), )
# assert that it properly lookups the currently active language
for lang_code, _ in settings.LANGUAGES:
translation.activate(lang_code)
assert self.TestModel.objects.filter(text='text_' +
lang_code).exists()
# ensure that the default language is used in case no
# language is active at all
translation.deactivate_all()
assert self.TestModel.objects.filter(text='text_en').exists()
# ensure that hstore lookups still work
assert self.TestModel.objects.filter(text__ro='text_ro').exists()
def get_data_sources(dic=False):
"""Get all configured DataSources.
:param dic: Should return a dict
:return: List of DataSource-objects if dic False otherwise dict
"""
data_source_classes = [
import_string(cls) for cls in settings.DATA_SOURCE_CLASSES
]
if dic:
return {ds.__name__: ds for ds in data_source_classes}
return [
DataSource(
name=ds.__name__,
info=LocalizedValue(ds.info).translate() if isinstance(
ds.info, dict) else ds.info,
) for ds in data_source_classes
]
def get_prep_value(self, value):
"""Returns field's value prepared for saving into a database."""
if isinstance(value, LocalizedValue):
prep_value = LocalizedValue()
for k, v in value.__dict__.items():
if v is None:
prep_value.set(k, "")
else:
# Need to convert File objects provided via a form to
# unicode for database insertion
prep_value.set(k, str(v))
return super().get_prep_value(prep_value)
return super().get_prep_value(value)
def test_translate_none():
"""Tests whether the :see:LocalizedValue class's translate() method
properly returns None when there is no value."""
# with no value, we always expect it to return None
localized_value = LocalizedValue()
assert localized_value.translate() is None
assert str(localized_value) == ""
# with no value for the default language, the default
# behavior is to return None, unless a custom fallback
# chain is configured, which there is not for this test
other_language = settings.LANGUAGES[-1][0]
localized_value = LocalizedValue({other_language: "hey"})
translation.activate(settings.LANGUAGE_CODE)
assert localized_value.translate() is None
assert str(localized_value) == ""
