pub/django-localized-fields
1
0
Fork 0
mirror of https://github.com/SectorLabs/django-localized-fields.git synced 2025-04-28 04:52:55 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Re-format all files

Browse Source
This commit is contained in:
Swen Kooij 2019-10-19 12:43:17 +03:00
parent 4ee1a5f487
commit 7cdd1f4490
41 changed files with 836 additions and 812 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
localized_fields/__init__.py
View File

@ -1 +1 @@
default_app_config = 'localized_fields.apps.LocalizedFieldsConfig' default_app_config = "localized_fields.apps.LocalizedFieldsConfig"

27
localized_fields/admin.py
View File

@ -1,13 +1,16 @@
from . import widgets from . import widgets
from .fields import LocalizedField, LocalizedCharField, LocalizedTextField, \ from .fields import (
LocalizedFileField LocalizedCharField,
LocalizedField,
LocalizedFileField,
LocalizedTextField,
)
FORMFIELD_FOR_LOCALIZED_FIELDS_DEFAULTS = { FORMFIELD_FOR_LOCALIZED_FIELDS_DEFAULTS = {
LocalizedField: {'widget': widgets.AdminLocalizedFieldWidget}, LocalizedField: {"widget": widgets.AdminLocalizedFieldWidget},
LocalizedCharField: {'widget': widgets.AdminLocalizedCharFieldWidget}, LocalizedCharField: {"widget": widgets.AdminLocalizedCharFieldWidget},
LocalizedTextField: {'widget': widgets.AdminLocalizedFieldWidget}, LocalizedTextField: {"widget": widgets.AdminLocalizedFieldWidget},
LocalizedFileField: {'widget': widgets.AdminLocalizedFileFieldWidget}, LocalizedFileField: {"widget": widgets.AdminLocalizedFileFieldWidget},
} }
@ -15,15 +18,11 @@ class LocalizedFieldsAdminMixin:
"""Mixin for making the fancy widgets work in Django Admin.""" """Mixin for making the fancy widgets work in Django Admin."""
class Media: class Media:
css = { css = {"all": ("localized_fields/localized-fields-admin.css",)}
'all': (
'localized_fields/localized-fields-admin.css',
)
}
js = ( js = (
'admin/js/jquery.init.js', "admin/js/jquery.init.js",
'localized_fields/localized-fields-admin.js', "localized_fields/localized-fields-admin.js",
) )
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):

4
localized_fields/apps.py
View File

@ -9,10 +9,10 @@ from .lookups import LocalizedLookupMixin
class LocalizedFieldsConfig(AppConfig): class LocalizedFieldsConfig(AppConfig):
name = 'localized_fields' name = "localized_fields"
def ready(self): def ready(self):
if getattr(settings, 'LOCALIZED_FIELDS_EXPERIMENTAL', False): if getattr(settings, "LOCALIZED_FIELDS_EXPERIMENTAL", False):
for _, clazz in inspect.getmembers(lookups): for _, clazz in inspect.getmembers(lookups):
if not inspect.isclass(clazz) or clazz is LocalizedLookupMixin: if not inspect.isclass(clazz) or clazz is LocalizedLookupMixin:
continue continue

7
localized_fields/descriptor.py
View File

@ -3,8 +3,7 @@ from django.utils import six, translation
class LocalizedValueDescriptor: class LocalizedValueDescriptor:
""" """The descriptor for the localized value attribute on the model instance.
The descriptor for the localized value attribute on the model instance.
Returns a :see:LocalizedValue when accessed so you can do stuff like:: Returns a :see:LocalizedValue when accessed so you can do stuff like::
>>> from myapp.models import MyModel >>> from myapp.models import MyModel
@ -60,6 +59,8 @@ class LocalizedValueDescriptor:
def __set__(self, instance, value): def __set__(self, instance, value):
if isinstance(value, six.string_types): if isinstance(value, six.string_types):
language = translation.get_language() or settings.LANGUAGE_CODE language = translation.get_language() or settings.LANGUAGE_CODE
self.__get__(instance).set(language, value) # pylint: disable=no-member self.__get__(instance).set(
language, value
) # pylint: disable=no-member
else: else:
instance.__dict__[self.field.name] = value instance.__dict__[self.field.name] = value

7
localized_fields/expressions.py
View File

@ -1,14 +1,13 @@
from django.conf import settings from django.conf import settings
from django.utils import translation from django.utils import translation
from psqlextra import expressions from psqlextra import expressions
class LocalizedRef(expressions.HStoreRef): class LocalizedRef(expressions.HStoreRef):
"""Expression that selects the value in a field only in """Expression that selects the value in a field only in the currently
the currently active language.""" active language."""
def __init__(self, name: str, lang: str=None): def __init__(self, name: str, lang: str = None):
"""Initializes a new instance of :see:LocalizedRef. """Initializes a new instance of :see:LocalizedRef.
Arguments: Arguments:

26
localized_fields/fields/__init__.py
View File

@ -1,26 +1,24 @@
from .field import LocalizedField
from .autoslug_field import LocalizedAutoSlugField from .autoslug_field import LocalizedAutoSlugField
from .uniqueslug_field import LocalizedUniqueSlugField
from .char_field import LocalizedCharField from .char_field import LocalizedCharField
from .text_field import LocalizedTextField from .field import LocalizedField
from .file_field import LocalizedFileField from .file_field import LocalizedFileField
from .integer_field import LocalizedIntegerField from .integer_field import LocalizedIntegerField
from .text_field import LocalizedTextField
from .uniqueslug_field import LocalizedUniqueSlugField
__all__ = [ __all__ = [
'LocalizedField', "LocalizedField",
'LocalizedAutoSlugField', "LocalizedAutoSlugField",
'LocalizedUniqueSlugField', "LocalizedUniqueSlugField",
'LocalizedCharField', "LocalizedCharField",
'LocalizedTextField', "LocalizedTextField",
'LocalizedFileField', "LocalizedFileField",
'LocalizedIntegerField' "LocalizedIntegerField",
] ]
try: try:
from .bleach_field import LocalizedBleachField from .bleach_field import LocalizedBleachField
__all__ += [
'LocalizedBleachField' __all__ += ["LocalizedBleachField"]
]
except ImportError: except ImportError:
pass pass

92
localized_fields/fields/autoslug_field.py
View File

@ -1,60 +1,53 @@
import warnings import warnings
from typing import Callable, Tuple, Union
from datetime import datetime from datetime import datetime
from typing import Callable, Tuple, Union
from django import forms from django import forms
from django.conf import settings from django.conf import settings
from django.utils import translation from django.utils import translation
from django.utils.text import slugify from django.utils.text import slugify
from .field import LocalizedField
from ..value import LocalizedValue
from ..util import resolve_object_property from ..util import resolve_object_property
from ..value import LocalizedValue
from .field import LocalizedField
class LocalizedAutoSlugField(LocalizedField): class LocalizedAutoSlugField(LocalizedField):
"""Automatically provides slugs for a localized """Automatically provides slugs for a localized field upon saving."""
field upon saving."""
warnings.warn( warnings.warn(
'LocalizedAutoSlug is deprecated and will be removed in the next major version.', "LocalizedAutoSlug is deprecated and will be removed in the next major version.",
DeprecationWarning DeprecationWarning,
) )
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
"""Initializes a new instance of :see:LocalizedAutoSlugField.""" """Initializes a new instance of :see:LocalizedAutoSlugField."""
self.populate_from = kwargs.pop('populate_from', None) self.populate_from = kwargs.pop("populate_from", None)
self.include_time = kwargs.pop('include_time', False) self.include_time = kwargs.pop("include_time", False)
super(LocalizedAutoSlugField, self).__init__( super(LocalizedAutoSlugField, self).__init__(*args, **kwargs)
*args,
**kwargs
)
def deconstruct(self): def deconstruct(self):
"""Deconstructs the field into something the database """Deconstructs the field into something the database can store."""
can store."""
name, path, args, kwargs = super( name, path, args, kwargs = super(
LocalizedAutoSlugField, self).deconstruct() LocalizedAutoSlugField, self
).deconstruct()
kwargs['populate_from'] = self.populate_from kwargs["populate_from"] = self.populate_from
kwargs['include_time'] = self.include_time kwargs["include_time"] = self.include_time
return name, path, args, kwargs return name, path, args, kwargs
def formfield(self, **kwargs): def formfield(self, **kwargs):
"""Gets the form field associated with this field. """Gets the form field associated with this field.
Because this is a slug field which is automatically Because this is a slug field which is automatically populated,
populated, it should be hidden from the form. it should be hidden from the form.
""" """
defaults = { defaults = {"form_class": forms.CharField, "required": False}
'form_class': forms.CharField,
'required': False
}
defaults.update(kwargs) defaults.update(kwargs)
@ -64,8 +57,7 @@ class LocalizedAutoSlugField(LocalizedField):
return form_field return form_field
def pre_save(self, instance, add: bool): def pre_save(self, instance, add: bool):
"""Ran just before the model is saved, allows us to built """Ran just before the model is saved, allows us to built the slug.
the slug.
Arguments: Arguments:
instance: instance:
@ -83,21 +75,19 @@ class LocalizedAutoSlugField(LocalizedField):
continue continue
if self.include_time: if self.include_time:
value += '-%s' % datetime.now().microsecond value += "-%s" % datetime.now().microsecond
def is_unique(slug: str, language: str) -> bool: def is_unique(slug: str, language: str) -> bool:
"""Gets whether the specified slug is unique.""" """Gets whether the specified slug is unique."""
unique_filter = { unique_filter = {"%s__%s" % (self.name, language): slug}
'%s__%s' % (self.name, language): slug
}
return not type(instance).objects.filter(**unique_filter).exists() return (
not type(instance).objects.filter(**unique_filter).exists()
)
slug = self._make_unique_slug( slug = self._make_unique_slug(
slugify(value, allow_unicode=True), slugify(value, allow_unicode=True), lang_code, is_unique
lang_code,
is_unique
) )
slugs.set(lang_code, slug) slugs.set(lang_code, slug)
@ -106,9 +96,11 @@ class LocalizedAutoSlugField(LocalizedField):
return slugs return slugs
@staticmethod @staticmethod
def _make_unique_slug(slug: str, language: str, is_unique: Callable[[str], bool]) -> str: def _make_unique_slug(
"""Guarentees that the specified slug is unique by appending slug: str, language: str, is_unique: Callable[[str], bool]
a number until it is unique. ) -> str:
"""Guarentees that the specified slug is unique by appending a number
until it is unique.
Arguments: Arguments:
slug: slug:
@ -126,14 +118,14 @@ class LocalizedAutoSlugField(LocalizedField):
unique_slug = slug unique_slug = slug
while not is_unique(unique_slug, language): while not is_unique(unique_slug, language):
unique_slug = '%s-%d' % (slug, index) unique_slug = "%s-%d" % (slug, index)
index += 1 index += 1
return unique_slug return unique_slug
def _get_populate_values(self, instance) -> Tuple[str, str]: def _get_populate_values(self, instance) -> Tuple[str, str]:
"""Gets all values (for each language) from the """Gets all values (for each language) from the specified's instance's
specified's instance's `populate_from` field. `populate_from` field.
Arguments: Arguments:
instance: instance:
@ -147,16 +139,16 @@ class LocalizedAutoSlugField(LocalizedField):
( (
lang_code, lang_code,
self._get_populate_from_value( self._get_populate_from_value(
instance, instance, self.populate_from, lang_code
self.populate_from,
lang_code
), ),
) )
for lang_code, _ in settings.LANGUAGES for lang_code, _ in settings.LANGUAGES
] ]
@staticmethod @staticmethod
def _get_populate_from_value(instance, field_name: Union[str, Tuple[str]], language: str): def _get_populate_from_value(
instance, field_name: Union[str, Tuple[str]], language: str
):
"""Gets the value to create a slug from in the specified language. """Gets the value to create a slug from in the specified language.
Arguments: Arguments:
@ -182,11 +174,13 @@ class LocalizedAutoSlugField(LocalizedField):
return str(value) return str(value)
if isinstance(field_name, tuple) or isinstance(field_name, list): if isinstance(field_name, tuple) or isinstance(field_name, list):
value = '-'.join([ value = "-".join(
value [
for value in [get_field_value(name) for name in field_name] value
if value for value in [get_field_value(name) for name in field_name]
]) if value
]
)
return value return value
return get_field_value(field_name) return get_field_value(field_name)

10
localized_fields/fields/bleach_field.py
View File

@ -7,12 +7,11 @@ from .field import LocalizedField
class LocalizedBleachField(LocalizedField): class LocalizedBleachField(LocalizedField):
"""Custom version of :see:BleachField that """Custom version of :see:BleachField that is actually a
is actually a :see:LocalizedField.""" :see:LocalizedField."""
def pre_save(self, instance, add: bool): def pre_save(self, instance, add: bool):
"""Ran just before the model is saved, allows us to built """Ran just before the model is saved, allows us to built the slug.
the slug.
Arguments: Arguments:
instance: instance:
@ -33,8 +32,7 @@ class LocalizedBleachField(LocalizedField):
continue continue
localized_value.set( localized_value.set(
lang_code, lang_code, bleach.clean(value, **get_bleach_default_options())
bleach.clean(value, **get_bleach_default_options())
) )
return localized_value return localized_value

6
localized_fields/fields/char_field.py
View File

@ -1,6 +1,6 @@
from ..forms import LocalizedCharFieldForm from ..forms import LocalizedCharFieldForm
from .field import LocalizedField
from ..value import LocalizedStringValue from ..value import LocalizedStringValue
from .field import LocalizedField
class LocalizedCharField(LocalizedField): class LocalizedCharField(LocalizedField):
@ -8,9 +8,7 @@ class LocalizedCharField(LocalizedField):
def formfield(self, **kwargs): def formfield(self, **kwargs):
"""Gets the form field associated with this field.""" """Gets the form field associated with this field."""
defaults = { defaults = {"form_class": LocalizedCharFieldForm}
'form_class': LocalizedCharFieldForm
}
defaults.update(kwargs) defaults.update(kwargs)
return super().formfield(**defaults) return super().formfield(**defaults)

39
localized_fields/fields/field.py
View File

@ -1,22 +1,22 @@
import json import json
from typing import Union, List, Optional from typing import List, Optional, Union
from django.conf import settings from django.conf import settings
from django.db.utils import IntegrityError from django.db.utils import IntegrityError
from psqlextra.fields import HStoreField from psqlextra.fields import HStoreField
from ..descriptor import LocalizedValueDescriptor
from ..forms import LocalizedFieldForm from ..forms import LocalizedFieldForm
from ..value import LocalizedValue from ..value import LocalizedValue
from ..descriptor import LocalizedValueDescriptor
class LocalizedField(HStoreField): class LocalizedField(HStoreField):
"""A field that has the same value in multiple languages. """A field that has the same value in multiple languages.
Internally this is stored as a :see:HStoreField where there Internally this is stored as a :see:HStoreField where there is a key
is a key for every language.""" for every language.
"""
Meta = None Meta = None
@ -27,7 +27,9 @@ class LocalizedField(HStoreField):
# The descriptor to use for accessing the attribute off of the class. # The descriptor to use for accessing the attribute off of the class.
descriptor_class = LocalizedValueDescriptor descriptor_class = LocalizedValueDescriptor
def __init__(self, *args, required: Union[bool, List[str]]=None, **kwargs): def __init__(
self, *args, required: Union[bool, List[str]] = None, **kwargs
):
"""Initializes a new instance of :see:LocalizedField.""" """Initializes a new instance of :see:LocalizedField."""
super(LocalizedField, self).__init__(*args, required=required, **kwargs) super(LocalizedField, self).__init__(*args, required=required, **kwargs)
@ -54,8 +56,7 @@ class LocalizedField(HStoreField):
@classmethod @classmethod
def from_db_value(cls, value, *_) -> Optional[LocalizedValue]: def from_db_value(cls, value, *_) -> Optional[LocalizedValue]:
"""Turns the specified database value into its Python """Turns the specified database value into its Python equivalent.
equivalent.
Arguments: Arguments:
value: value:
@ -68,7 +69,7 @@ class LocalizedField(HStoreField):
""" """
if not value: if not value:
if getattr(settings, 'LOCALIZED_FIELDS_EXPERIMENTAL', False): if getattr(settings, "LOCALIZED_FIELDS_EXPERIMENTAL", False):
return None return None
else: else:
return cls.attr_class() return cls.attr_class()
@ -98,8 +99,7 @@ class LocalizedField(HStoreField):
return cls.attr_class(value) return cls.attr_class(value)
def to_python(self, value: Union[dict, str, None]) -> LocalizedValue: def to_python(self, value: Union[dict, str, None]) -> LocalizedValue:
"""Turns the specified database value into its Python """Turns the specified database value into its Python equivalent.
equivalent.
Arguments: Arguments:
value: value:
@ -124,8 +124,7 @@ class LocalizedField(HStoreField):
return self.attr_class(deserialized_value) return self.attr_class(deserialized_value)
def get_prep_value(self, value: LocalizedValue) -> dict: def get_prep_value(self, value: LocalizedValue) -> dict:
"""Turns the specified value into something the database """Turns the specified value into something the database can store.
can store.
If an illegal value (non-LocalizedValue instance) is If an illegal value (non-LocalizedValue instance) is
specified, we'll treat it as an empty :see:LocalizedValue specified, we'll treat it as an empty :see:LocalizedValue
@ -161,8 +160,8 @@ class LocalizedField(HStoreField):
) )
def clean(self, value, *_): def clean(self, value, *_):
"""Cleans the specified value into something we """Cleans the specified value into something we can store in the
can store in the database. database.
For example, when all the language fields are For example, when all the language fields are
left empty, and the field is allowed to be null, left empty, and the field is allowed to be null,
@ -195,7 +194,7 @@ class LocalizedField(HStoreField):
def validate(self, value: LocalizedValue, *_): def validate(self, value: LocalizedValue, *_):
"""Validates that the values has been filled in for all required """Validates that the values has been filled in for all required
languages languages.
Exceptions are raises in order to notify the user Exceptions are raises in order to notify the user
of invalid values. of invalid values.
@ -212,15 +211,17 @@ class LocalizedField(HStoreField):
lang_val = getattr(value, settings.LANGUAGE_CODE) lang_val = getattr(value, settings.LANGUAGE_CODE)
if lang_val is None: if lang_val is None:
raise IntegrityError('null value in column "%s.%s" violates ' raise IntegrityError(
'not-null constraint' % (self.name, lang)) 'null value in column "%s.%s" violates '
"not-null constraint" % (self.name, lang)
)
def formfield(self, **kwargs): def formfield(self, **kwargs):
"""Gets the form field associated with this field.""" """Gets the form field associated with this field."""
defaults = dict( defaults = dict(
form_class=LocalizedFieldForm, form_class=LocalizedFieldForm,
required=False if self.blank else self.required required=False if self.blank else self.required,
) )
defaults.update(kwargs) defaults.update(kwargs)
return super().formfield(**defaults) return super().formfield(**defaults)

53
localized_fields/fields/file_field.py
View File

@ -1,31 +1,31 @@
import json
import datetime import datetime
import json
import posixpath import posixpath
from django.core.files import File from django.core.files import File
from django.core.files.storage import default_storage
from django.db.models.fields.files import FieldFile from django.db.models.fields.files import FieldFile
from django.utils import six from django.utils import six
from django.core.files.storage import default_storage
from django.utils.encoding import force_str, force_text from django.utils.encoding import force_str, force_text
from localized_fields.fields import LocalizedField from localized_fields.fields import LocalizedField
from localized_fields.fields.field import LocalizedValueDescriptor from localized_fields.fields.field import LocalizedValueDescriptor
from localized_fields.value import LocalizedValue from localized_fields.value import LocalizedValue
from ..value import LocalizedFileValue
from ..forms import LocalizedFileFieldForm from ..forms import LocalizedFileFieldForm
from ..value import LocalizedFileValue
class LocalizedFieldFile(FieldFile): class LocalizedFieldFile(FieldFile):
def __init__(self, instance, field, name, lang): def __init__(self, instance, field, name, lang):
super().__init__(instance, field, name) super().__init__(instance, field, name)
self.lang = lang self.lang = lang
def save(self, name, content, save=True): def save(self, name, content, save=True):
name = self.field.generate_filename(self.instance, name, self.lang) name = self.field.generate_filename(self.instance, name, self.lang)
self.name = self.storage.save(name, content, self.name = self.storage.save(
max_length=self.field.max_length) name, content, max_length=self.field.max_length
)
self._committed = True self._committed = True
if save: if save:
@ -37,7 +37,7 @@ class LocalizedFieldFile(FieldFile):
if not self: if not self:
return return
if hasattr(self, '_file'): if hasattr(self, "_file"):
self.close() self.close()
del self.file del self.file
@ -60,24 +60,29 @@ class LocalizedFileValueDescriptor(LocalizedValueDescriptor):
file = self.field.value_class(instance, self.field, file, lang) file = self.field.value_class(instance, self.field, file, lang)
value.set(lang, file) value.set(lang, file)
elif isinstance(file, File) and \ elif isinstance(file, File) and not isinstance(
not isinstance(file, LocalizedFieldFile): file, LocalizedFieldFile
file_copy = self.field.value_class(instance, self.field, ):
file.name, lang) file_copy = self.field.value_class(
instance, self.field, file.name, lang
)
file_copy.file = file file_copy.file = file
file_copy._committed = False file_copy._committed = False
value.set(lang, file_copy) value.set(lang, file_copy)
elif isinstance(file, LocalizedFieldFile) and \ elif isinstance(file, LocalizedFieldFile) and not hasattr(
not hasattr(file, 'field'): file, "field"
):
file.instance = instance file.instance = instance
file.field = self.field file.field = self.field
file.storage = self.field.storage file.storage = self.field.storage
file.lang = lang file.lang = lang
# Make sure that the instance is correct. # Make sure that the instance is correct.
elif isinstance(file, LocalizedFieldFile) \ elif (
and instance is not file.instance: isinstance(file, LocalizedFieldFile)
and instance is not file.instance
):
file.instance = instance file.instance = instance
file.lang = lang file.lang = lang
return value return value
@ -88,8 +93,9 @@ class LocalizedFileField(LocalizedField):
attr_class = LocalizedFileValue attr_class = LocalizedFileValue
value_class = LocalizedFieldFile value_class = LocalizedFieldFile
def __init__(self, verbose_name=None, name=None, upload_to='', storage=None, def __init__(
**kwargs): self, verbose_name=None, name=None, upload_to="", storage=None, **kwargs
):
self.storage = storage or default_storage self.storage = storage or default_storage
self.upload_to = upload_to self.upload_to = upload_to
@ -98,9 +104,9 @@ class LocalizedFileField(LocalizedField):
def deconstruct(self): def deconstruct(self):
name, path, args, kwargs = super().deconstruct() name, path, args, kwargs = super().deconstruct()
kwargs['upload_to'] = self.upload_to kwargs["upload_to"] = self.upload_to
if self.storage is not default_storage: if self.storage is not default_storage:
kwargs['storage'] = self.storage kwargs["storage"] = self.storage
return name, path, args, kwargs return name, path, args, kwargs
def get_prep_value(self, value): def get_prep_value(self, value):
@ -110,7 +116,7 @@ class LocalizedFileField(LocalizedField):
prep_value = LocalizedValue() prep_value = LocalizedValue()
for k, v in value.__dict__.items(): for k, v in value.__dict__.items():
if v is None: if v is None:
prep_value.set(k, '') prep_value.set(k, "")
else: else:
# Need to convert File objects provided via a form to # Need to convert File objects provided via a form to
# unicode for database insertion # unicode for database insertion
@ -141,18 +147,17 @@ class LocalizedFileField(LocalizedField):
if isinstance(data, LocalizedValue): if isinstance(data, LocalizedValue):
for k, v in data.__dict__.items(): for k, v in data.__dict__.items():
if v is not None and not v: if v is not None and not v:
data.set(k, '') data.set(k, "")
setattr(instance, self.name, data) setattr(instance, self.name, data)
def formfield(self, **kwargs): def formfield(self, **kwargs):
defaults = {'form_class': LocalizedFileFieldForm} defaults = {"form_class": LocalizedFileFieldForm}
defaults.update(kwargs) defaults.update(kwargs)
return super().formfield(**defaults) return super().formfield(**defaults)
def value_to_string(self, obj): def value_to_string(self, obj):
value = self.value_from_object(obj) value = self.value_from_object(obj)
if isinstance(value, LocalizedFileValue): if isinstance(value, LocalizedFileValue):
return json.dumps({k: v.name for k, v return json.dumps({k: v.name for k, v in value.__dict__.items()})
in value.__dict__.items()})
else: else:
return super().value_to_string(obj) return super().value_to_string(obj)

30
localized_fields/fields/integer_field.py
View File

@ -1,11 +1,11 @@
from typing import Optional, Union, Dict from typing import Dict, Optional, Union
from django.conf import settings from django.conf import settings
from django.db.utils import IntegrityError from django.db.utils import IntegrityError
from .field import LocalizedField
from ..value import LocalizedValue, LocalizedIntegerValue
from ..forms import LocalizedIntegerFieldForm from ..forms import LocalizedIntegerFieldForm
from ..value import LocalizedIntegerValue, LocalizedValue
from .field import LocalizedField
class LocalizedIntegerField(LocalizedField): class LocalizedIntegerField(LocalizedField):
@ -27,7 +27,9 @@ class LocalizedIntegerField(LocalizedField):
return cls._convert_localized_value(db_value) return cls._convert_localized_value(db_value)
def to_python(self, value: Union[Dict[str, int], int, None]) -> LocalizedIntegerValue: def to_python(
self, value: Union[Dict[str, int], int, None]
) -> LocalizedIntegerValue:
"""Converts the value from a database value into a Python value.""" """Converts the value from a database value into a Python value."""
db_value = super().to_python(value) db_value = super().to_python(value)
@ -55,32 +57,36 @@ class LocalizedIntegerField(LocalizedField):
if local_value is not None: if local_value is not None:
int(local_value) int(local_value)
except (TypeError, ValueError): except (TypeError, ValueError):
raise IntegrityError('non-integer value in column "%s.%s" violates ' raise IntegrityError(
'integer constraint' % (self.name, lang_code)) 'non-integer value in column "%s.%s" violates '
"integer constraint" % (self.name, lang_code)
)
# convert to a string before saving because the underlying # convert to a string before saving because the underlying
# type is hstore, which only accept strings # type is hstore, which only accept strings
prepped_value[lang_code] = str(local_value) if local_value is not None else None prepped_value[lang_code] = (
str(local_value) if local_value is not None else None
)
return prepped_value return prepped_value
def formfield(self, **kwargs): def formfield(self, **kwargs):
"""Gets the form field associated with this field.""" """Gets the form field associated with this field."""
defaults = { defaults = {"form_class": LocalizedIntegerFieldForm}
'form_class': LocalizedIntegerFieldForm
}
defaults.update(kwargs) defaults.update(kwargs)
return super().formfield(**defaults) return super().formfield(**defaults)
@staticmethod @staticmethod
def _convert_localized_value(value: LocalizedValue) -> LocalizedIntegerValue: def _convert_localized_value(
value: LocalizedValue
) -> LocalizedIntegerValue:
"""Converts from :see:LocalizedValue to :see:LocalizedIntegerValue.""" """Converts from :see:LocalizedValue to :see:LocalizedIntegerValue."""
integer_values = {} integer_values = {}
for lang_code, _ in settings.LANGUAGES: for lang_code, _ in settings.LANGUAGES:
local_value = value.get(lang_code, None) local_value = value.get(lang_code, None)
if local_value is None or local_value.strip() == '': if local_value is None or local_value.strip() == "":
local_value = None local_value = None
try: try:

4
localized_fields/fields/text_field.py
View File

@ -6,9 +6,7 @@ class LocalizedTextField(LocalizedCharField):
def formfield(self, **kwargs): def formfield(self, **kwargs):
"""Gets the form field associated with this field.""" """Gets the form field associated with this field."""
defaults = { defaults = {"form_class": LocalizedTextFieldForm}
'form_class': LocalizedTextFieldForm
}
defaults.update(kwargs) defaults.update(kwargs)
return super().formfield(**defaults) return super().formfield(**defaults)

55
localized_fields/fields/uniqueslug_field.py
View File

@ -1,17 +1,16 @@
from datetime import datetime from datetime import datetime
from django.utils.text import slugify
from django.core.exceptions import ImproperlyConfigured from django.core.exceptions import ImproperlyConfigured
from django.utils.text import slugify
from .autoslug_field import LocalizedAutoSlugField
from ..util import get_language_codes
from ..mixins import AtomicSlugRetryMixin from ..mixins import AtomicSlugRetryMixin
from ..util import get_language_codes
from ..value import LocalizedValue from ..value import LocalizedValue
from .autoslug_field import LocalizedAutoSlugField
class LocalizedUniqueSlugField(LocalizedAutoSlugField): class LocalizedUniqueSlugField(LocalizedAutoSlugField):
"""Automatically provides slugs for a localized """Automatically provides slugs for a localized field upon saving.".
field upon saving."
An improved version of :see:LocalizedAutoSlugField, An improved version of :see:LocalizedAutoSlugField,
which adds: which adds:
@ -27,30 +26,26 @@ class LocalizedUniqueSlugField(LocalizedAutoSlugField):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
"""Initializes a new instance of :see:LocalizedUniqueSlugField.""" """Initializes a new instance of :see:LocalizedUniqueSlugField."""
kwargs['uniqueness'] = kwargs.pop('uniqueness', get_language_codes()) kwargs["uniqueness"] = kwargs.pop("uniqueness", get_language_codes())
super(LocalizedUniqueSlugField, self).__init__( super(LocalizedUniqueSlugField, self).__init__(*args, **kwargs)
*args,
**kwargs
)
self.populate_from = kwargs.pop('populate_from') self.populate_from = kwargs.pop("populate_from")
self.include_time = kwargs.pop('include_time', False) self.include_time = kwargs.pop("include_time", False)
def deconstruct(self): def deconstruct(self):
"""Deconstructs the field into something the database """Deconstructs the field into something the database can store."""
can store."""
name, path, args, kwargs = super( name, path, args, kwargs = super(
LocalizedUniqueSlugField, self).deconstruct() LocalizedUniqueSlugField, self
).deconstruct()
kwargs['populate_from'] = self.populate_from kwargs["populate_from"] = self.populate_from
kwargs['include_time'] = self.include_time kwargs["include_time"] = self.include_time
return name, path, args, kwargs return name, path, args, kwargs
def pre_save(self, instance, add: bool): def pre_save(self, instance, add: bool):
"""Ran just before the model is saved, allows us to built """Ran just before the model is saved, allows us to built the slug.
the slug.
Arguments: Arguments:
instance: instance:
@ -65,10 +60,13 @@ class LocalizedUniqueSlugField(LocalizedAutoSlugField):
""" """
if not isinstance(instance, AtomicSlugRetryMixin): if not isinstance(instance, AtomicSlugRetryMixin):
raise ImproperlyConfigured(( raise ImproperlyConfigured(
'Model \'%s\' does not inherit from AtomicSlugRetryMixin. ' (
'Without this, the LocalizedUniqueSlugField will not work.' "Model '%s' does not inherit from AtomicSlugRetryMixin. "
) % type(instance).__name__) "Without this, the LocalizedUniqueSlugField will not work."
)
% type(instance).__name__
)
slugs = LocalizedValue() slugs = LocalizedValue()
@ -83,20 +81,21 @@ class LocalizedUniqueSlugField(LocalizedAutoSlugField):
if instance.pk is not None: if instance.pk is not None:
current_slug = getattr(instance, self.name).get(lang_code) current_slug = getattr(instance, self.name).get(lang_code)
if current_slug is not None: if current_slug is not None:
stripped_slug = current_slug[0:current_slug.rfind('-')] current_slug_end_index = current_slug.rfind("-")
stripped_slug = current_slug[0:current_slug_end_index]
if slug == stripped_slug: if slug == stripped_slug:
slugs.set(lang_code, current_slug) slugs.set(lang_code, current_slug)
continue continue
if self.include_time: if self.include_time:
slug += '-%d' % datetime.now().microsecond slug += "-%d" % datetime.now().microsecond
retries = getattr(instance, 'retries', 0) retries = getattr(instance, "retries", 0)
if retries > 0: if retries > 0:
# do not add another - if we already added time # do not add another - if we already added time
if not self.include_time: if not self.include_time:
slug += '-' slug += "-"
slug += '%d' % retries slug += "%d" % retries
slugs.set(lang_code, slug) slugs.set(lang_code, slug)

98
localized_fields/forms.py
View File

@ -5,30 +5,41 @@ from django.conf import settings
from django.core.exceptions import ValidationError from django.core.exceptions import ValidationError
from django.forms.widgets import FILE_INPUT_CONTRADICTION from django.forms.widgets import FILE_INPUT_CONTRADICTION
from .value import LocalizedValue, LocalizedStringValue, \ from .value import (
LocalizedFileValue, LocalizedIntegerValue LocalizedFileValue,
from .widgets import LocalizedFieldWidget, LocalizedCharFieldWidget, \ LocalizedIntegerValue,
LocalizedFileWidget, AdminLocalizedIntegerFieldWidget LocalizedStringValue,
LocalizedValue,
)
from .widgets import (
AdminLocalizedIntegerFieldWidget,
LocalizedCharFieldWidget,
LocalizedFieldWidget,
LocalizedFileWidget,
)
class LocalizedFieldForm(forms.MultiValueField): class LocalizedFieldForm(forms.MultiValueField):
"""Form for a localized field, allows editing """Form for a localized field, allows editing the field in multiple
the field in multiple languages.""" languages."""
widget = LocalizedFieldWidget widget = LocalizedFieldWidget
field_class = forms.fields.CharField field_class = forms.fields.CharField
value_class = LocalizedValue value_class = LocalizedValue
def __init__(self, *args, required: Union[bool, List[str]]=False, **kwargs): def __init__(
self, *args, required: Union[bool, List[str]] = False, **kwargs
):
"""Initializes a new instance of :see:LocalizedFieldForm.""" """Initializes a new instance of :see:LocalizedFieldForm."""
fields = [] fields = []
for lang_code, _ in settings.LANGUAGES: for lang_code, _ in settings.LANGUAGES:
field_options = dict( field_options = dict(
required=required if type(required) is bool else (lang_code in required=required
required), if type(required) is bool
label=lang_code else (lang_code in required),
label=lang_code,
) )
fields.append(self.field_class(**field_options)) fields.append(self.field_class(**field_options))
@ -36,7 +47,8 @@ class LocalizedFieldForm(forms.MultiValueField):
fields, fields,
required=required if type(required) is bool else True, required=required if type(required) is bool else True,
require_all_fields=False, require_all_fields=False,
*args, **kwargs *args,
**kwargs
) )
# set 'required' attribute for each widget separately # set 'required' attribute for each widget separately
@ -44,8 +56,8 @@ class LocalizedFieldForm(forms.MultiValueField):
widget.is_required = field.required widget.is_required = field.required
def compress(self, value: List[str]) -> value_class: def compress(self, value: List[str]) -> value_class:
"""Compresses the values from individual fields """Compresses the values from individual fields into a single
into a single :see:LocalizedValue instance. :see:LocalizedValue instance.
Arguments: Arguments:
value: value:
@ -65,41 +77,41 @@ class LocalizedFieldForm(forms.MultiValueField):
class LocalizedCharFieldForm(LocalizedFieldForm): class LocalizedCharFieldForm(LocalizedFieldForm):
"""Form for a localized char field, allows editing """Form for a localized char field, allows editing the field in multiple
the field in multiple languages.""" languages."""
widget = LocalizedCharFieldWidget widget = LocalizedCharFieldWidget
value_class = LocalizedStringValue value_class = LocalizedStringValue
class LocalizedTextFieldForm(LocalizedFieldForm): class LocalizedTextFieldForm(LocalizedFieldForm):
"""Form for a localized text field, allows editing """Form for a localized text field, allows editing the field in multiple
the field in multiple languages.""" languages."""
value_class = LocalizedStringValue value_class = LocalizedStringValue
class LocalizedIntegerFieldForm(LocalizedFieldForm): class LocalizedIntegerFieldForm(LocalizedFieldForm):
"""Form for a localized integer field, allows editing """Form for a localized integer field, allows editing the field in multiple
the field in multiple languages.""" languages."""
widget = AdminLocalizedIntegerFieldWidget widget = AdminLocalizedIntegerFieldWidget
value_class = LocalizedIntegerValue value_class = LocalizedIntegerValue
class LocalizedFileFieldForm(LocalizedFieldForm, forms.FileField): class LocalizedFileFieldForm(LocalizedFieldForm, forms.FileField):
"""Form for a localized file field, allows editing """Form for a localized file field, allows editing the field in multiple
the field in multiple languages.""" languages."""
widget = LocalizedFileWidget widget = LocalizedFileWidget
field_class = forms.fields.FileField field_class = forms.fields.FileField
value_class = LocalizedFileValue value_class = LocalizedFileValue
def clean(self, value, initial=None): def clean(self, value, initial=None):
""" """Most part of this method is a copy of
Most part of this method is a copy of django.forms.MultiValueField.clean, with the exception of initial value
django.forms.MultiValueField.clean, with the exception of initial handling (this need for correct processing FileField's).
value handling (this need for correct processing FileField's).
All original comments saved. All original comments saved.
""" """
if initial is None: if initial is None:
@ -111,16 +123,21 @@ class LocalizedFileFieldForm(LocalizedFieldForm, forms.FileField):
clean_data = [] clean_data = []
errors = [] errors = []
if not value or isinstance(value, (list, tuple)): if not value or isinstance(value, (list, tuple)):
if (not value or not [v for v in value if if (
v not in self.empty_values]) \ not value
and (not initial or not [v for v in initial if or not [v for v in value if v not in self.empty_values]
v not in self.empty_values]): ) and (
not initial
or not [v for v in initial if v not in self.empty_values]
):
if self.required: if self.required:
raise ValidationError(self.error_messages['required'], raise ValidationError(
code='required') self.error_messages["required"], code="required"
)
else: else:
raise ValidationError(self.error_messages['invalid'], raise ValidationError(
code='invalid') self.error_messages["invalid"], code="invalid"
)
for i, field in enumerate(self.fields): for i, field in enumerate(self.fields):
try: try:
field_value = value[i] field_value = value[i]
@ -131,20 +148,23 @@ class LocalizedFileFieldForm(LocalizedFieldForm, forms.FileField):
except IndexError: except IndexError:
field_initial = None field_initial = None
if field_value in self.empty_values and \ if (
field_initial in self.empty_values: field_value in self.empty_values
and field_initial in self.empty_values
):
if self.require_all_fields: if self.require_all_fields:
# Raise a 'required' error if the MultiValueField is # Raise a 'required' error if the MultiValueField is
# required and any field is empty. # required and any field is empty.
if self.required: if self.required:
raise ValidationError(self.error_messages['required'], raise ValidationError(
code='required') self.error_messages["required"], code="required"
)
elif field.required: elif field.required:
# Otherwise, add an 'incomplete' error to the list of # Otherwise, add an 'incomplete' error to the list of
# collected errors and skip field cleaning, if a required # collected errors and skip field cleaning, if a required
# field is empty. # field is empty.
if field.error_messages['incomplete'] not in errors: if field.error_messages["incomplete"] not in errors:
errors.append(field.error_messages['incomplete']) errors.append(field.error_messages["incomplete"])
continue continue
try: try:
clean_data.append(field.clean(field_value, field_initial)) clean_data.append(field.clean(field_value, field_initial))

26
localized_fields/lookups.py
View File

@ -1,15 +1,29 @@
from django.conf import settings from django.conf import settings
from django.contrib.postgres.fields.hstore import KeyTransform from django.contrib.postgres.fields.hstore import KeyTransform
from django.contrib.postgres.lookups import (SearchLookup, TrigramSimilar, from django.contrib.postgres.lookups import (
Unaccent) SearchLookup,
TrigramSimilar,
Unaccent,
)
from django.db.models.expressions import Col from django.db.models.expressions import Col
from django.db.models.lookups import (Contains, EndsWith, Exact, IContains, from django.db.models.lookups import (
IEndsWith, IExact, In, IRegex, IsNull, Contains,
IStartsWith, Regex, StartsWith) EndsWith,
Exact,
IContains,
IEndsWith,
IExact,
In,
IRegex,
IsNull,
IStartsWith,
Regex,
StartsWith,
)
from django.utils import translation from django.utils import translation
class LocalizedLookupMixin(): class LocalizedLookupMixin:
def process_lhs(self, qn, connection): def process_lhs(self, qn, connection):
if isinstance(self.lhs, Col): if isinstance(self.lhs, Col):
language = translation.get_language() or settings.LANGUAGE_CODE language = translation.get_language() or settings.LANGUAGE_CODE

7
localized_fields/migrations/0001_initial.py
View File

@ -6,9 +6,6 @@ from django.db import migrations
class Migration(migrations.Migration): class Migration(migrations.Migration):
dependencies = [ dependencies = []
]
operations = [ operations = [HStoreExtension()]
HStoreExtension(),
]

16
localized_fields/mixins.py
View File

@ -1,22 +1,18 @@
from django.db import transaction
from django.conf import settings from django.conf import settings
from django.db import transaction
from django.db.utils import IntegrityError from django.db.utils import IntegrityError
class AtomicSlugRetryMixin: class AtomicSlugRetryMixin:
"""Makes :see:LocalizedUniqueSlugField work by retrying upon """Makes :see:LocalizedUniqueSlugField work by retrying upon violation of
violation of the UNIQUE constraint.""" the UNIQUE constraint."""
def save(self, *args, **kwargs): def save(self, *args, **kwargs):
"""Saves this model instance to the database.""" """Saves this model instance to the database."""
max_retries = getattr( max_retries = getattr(settings, "LOCALIZED_FIELDS_MAX_RETRIES", 100)
settings,
'LOCALIZED_FIELDS_MAX_RETRIES',
100
)
if not hasattr(self, 'retries'): if not hasattr(self, "retries"):
self.retries = 0 self.retries = 0
with transaction.atomic(): with transaction.atomic():
@ -28,7 +24,7 @@ class AtomicSlugRetryMixin:
# field class... we can also not only catch exceptions # field class... we can also not only catch exceptions
# that apply to slug fields... so yea.. this is as # that apply to slug fields... so yea.. this is as
# retarded as it gets... i am sorry :( # retarded as it gets... i am sorry :(
if 'slug' not in str(ex): if "slug" not in str(ex):
raise ex raise ex
if self.retries >= max_retries: if self.retries >= max_retries:

3
localized_fields/models.py
View File

@ -10,7 +10,8 @@ class LocalizedModel(AtomicSlugRetryMixin, PostgresModel):
from LocalizedModel. However, for certain features, this is required. from LocalizedModel. However, for certain features, this is required.
It is definitely needed for :see:LocalizedUniqueSlugField, unless you It is definitely needed for :see:LocalizedUniqueSlugField, unless you
manually inherit from AtomicSlugRetryMixin.""" manually inherit from AtomicSlugRetryMixin.
"""
class Meta: class Meta:
abstract = True abstract = True

7
localized_fields/util.py
View File

@ -15,10 +15,7 @@ def get_language_codes() -> List[str]:
in your project. in your project.
""" """
return [ return [lang_code for lang_code, _ in settings.LANGUAGES]
lang_code
for lang_code, _ in settings.LANGUAGES
]
def resolve_object_property(obj, path: str): def resolve_object_property(obj, path: str):
@ -38,7 +35,7 @@ def resolve_object_property(obj, path: str):
""" """
value = obj value = obj
for path_part in path.split('.'): for path_part in path.split("."):
value = getattr(value, path_part) value = getattr(value, path_part)
return value return value

81
localized_fields/value.py
View File

@ -1,7 +1,7 @@
import deprecation
from typing import Optional
from collections.abc import Iterable from collections.abc import Iterable
from typing import Optional
import deprecation
from django.conf import settings from django.conf import settings
from django.utils import translation from django.utils import translation
@ -9,9 +9,10 @@ from django.utils import translation
class LocalizedValue(dict): class LocalizedValue(dict):
"""Represents the value of a :see:LocalizedField.""" """Represents the value of a :see:LocalizedField."""
default_value = None default_value = None
def __init__(self, keys: dict=None): def __init__(self, keys: dict = None):
"""Initializes a new instance of :see:LocalizedValue. """Initializes a new instance of :see:LocalizedValue.
Arguments: Arguments:
@ -24,9 +25,8 @@ class LocalizedValue(dict):
super().__init__({}) super().__init__({})
self._interpret_value(keys) self._interpret_value(keys)
def get(self, language: str=None, default: str=None) -> str: def get(self, language: str = None, default: str = None) -> str:
"""Gets the underlying value in the specified or """Gets the underlying value in the specified or primary language.
primary language.
Arguments: Arguments:
language: language:
@ -65,12 +65,12 @@ class LocalizedValue(dict):
contained in this instance. contained in this instance.
""" """
path = 'localized_fields.value.%s' % self.__class__.__name__ path = "localized_fields.value.%s" % self.__class__.__name__
return path, [self.__dict__], {} return path, [self.__dict__], {}
def _interpret_value(self, value): def _interpret_value(self, value):
"""Interprets a value passed in the constructor as """Interprets a value passed in the constructor as a
a :see:LocalizedValue. :see:LocalizedValue.
If string: If string:
Assumes it's the default language. Assumes it's the default language.
@ -103,11 +103,10 @@ class LocalizedValue(dict):
self._interpret_value(val) self._interpret_value(val)
def translate(self) -> Optional[str]: def translate(self) -> Optional[str]:
"""Gets the value in the current language or falls """Gets the value in the current language or falls back to the next
back to the next language if there's no value in the language if there's no value in the current language."""
current language."""
fallbacks = getattr(settings, 'LOCALIZED_FIELDS_FALLBACKS', {}) fallbacks = getattr(settings, "LOCALIZED_FIELDS_FALLBACKS", {})
language = translation.get_language() or settings.LANGUAGE_CODE language = translation.get_language() or settings.LANGUAGE_CODE
languages = fallbacks.get(language, [settings.LANGUAGE_CODE])[:] languages = fallbacks.get(language, [settings.LANGUAGE_CODE])[:]
@ -121,15 +120,13 @@ class LocalizedValue(dict):
return None return None
def __str__(self) -> str: def __str__(self) -> str:
"""Gets the value in the current language or falls """Gets the value in the current language or falls back to the next
back to the next language if there's no value in the language if there's no value in the current language."""
current language."""
return self.translate() or '' return self.translate() or ""
def __eq__(self, other): def __eq__(self, other):
"""Compares :paramref:self to :paramref:other for """Compares :paramref:self to :paramref:other for equality.
equality.
Returns: Returns:
True when :paramref:self is equal to :paramref:other. True when :paramref:self is equal to :paramref:other.
@ -148,8 +145,7 @@ class LocalizedValue(dict):
return True return True
def __ne__(self, other): def __ne__(self, other):
"""Compares :paramref:self to :paramerf:other for """Compares :paramref:self to :paramerf:other for in-equality.
in-equality.
Returns: Returns:
True when :paramref:self is not equal to :paramref:other. True when :paramref:self is not equal to :paramref:other.
@ -174,34 +170,43 @@ class LocalizedValue(dict):
def __repr__(self): # pragma: no cover def __repr__(self): # pragma: no cover
"""Gets a textual representation of this object.""" """Gets a textual representation of this object."""
return '%s<%s> 0x%s' % (self.__class__.__name__, return "%s<%s> 0x%s" % (
self.__dict__, id(self)) self.__class__.__name__,
self.__dict__,
id(self),
)
class LocalizedStringValue(LocalizedValue): class LocalizedStringValue(LocalizedValue):
default_value = '' default_value = ""
class LocalizedFileValue(LocalizedValue): class LocalizedFileValue(LocalizedValue):
def __getattr__(self, name: str): def __getattr__(self, name: str):
"""Proxies access to attributes to attributes of LocalizedFile""" """Proxies access to attributes to attributes of LocalizedFile."""
value = self.get(translation.get_language()) value = self.get(translation.get_language())
if hasattr(value, name): if hasattr(value, name):
return getattr(value, name) return getattr(value, name)
raise AttributeError("'{}' object has no attribute '{}'". raise AttributeError(
format(self.__class__.__name__, name)) "'{}' object has no attribute '{}'".format(
self.__class__.__name__, name
)
)
def __str__(self) -> str: def __str__(self) -> str:
"""Returns string representation of value""" """Returns string representation of value."""
return str(super().__str__()) return str(super().__str__())
@deprecation.deprecated(deprecated_in='4.6', removed_in='5.0', @deprecation.deprecated(
current_version='4.6', deprecated_in="4.6",
details='Use the translate() function instead.') removed_in="5.0",
current_version="4.6",
details="Use the translate() function instead.",
)
def localized(self): def localized(self):
"""Returns value for current language""" """Returns value for current language."""
return self.get(translation.get_language()) return self.get(translation.get_language())
@ -212,11 +217,11 @@ class LocalizedIntegerValue(LocalizedValue):
default_value = None default_value = None
def translate(self): def translate(self):
"""Gets the value in the current language, or """Gets the value in the current language, or in the configured fallbck
in the configured fallbck language.""" language."""
value = super().translate() value = super().translate()
if value is None or (isinstance(value, str) and value.strip() == ''): if value is None or (isinstance(value, str) and value.strip() == ""):
return None return None
return int(value) return int(value)
@ -231,7 +236,7 @@ class LocalizedIntegerValue(LocalizedValue):
return int(value) return int(value)
def __str__(self) -> str: def __str__(self) -> str:
"""Returns string representation of value""" """Returns string representation of value."""
value = self.translate() value = self.translate()
return str(value) if value is not None else '' return str(value) if value is not None else ""

58
localized_fields/widgets.py
View File

@ -2,8 +2,8 @@ import copy
from typing import List from typing import List
from django.conf import settings
from django import forms from django import forms
from django.conf import settings
from django.contrib.admin import widgets from django.contrib.admin import widgets
from .value import LocalizedValue from .value import LocalizedValue
@ -11,27 +11,27 @@ from .value import LocalizedValue
class LocalizedFieldWidget(forms.MultiWidget): class LocalizedFieldWidget(forms.MultiWidget):
"""Widget that has an input box for every language.""" """Widget that has an input box for every language."""
template_name = 'localized_fields/multiwidget.html'
template_name = "localized_fields/multiwidget.html"
widget = forms.Textarea widget = forms.Textarea
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
"""Initializes a new instance of :see:LocalizedFieldWidget.""" """Initializes a new instance of :see:LocalizedFieldWidget."""
initial_widgets = [ initial_widgets = [copy.copy(self.widget) for _ in settings.LANGUAGES]
copy.copy(self.widget)
for _ in settings.LANGUAGES
]
super().__init__(initial_widgets, *args, **kwargs) super().__init__(initial_widgets, *args, **kwargs)
for ((lang_code, lang_name), widget) in zip(settings.LANGUAGES, self.widgets): for ((lang_code, lang_name), widget) in zip(
widget.attrs['lang'] = lang_code settings.LANGUAGES, self.widgets
):
widget.attrs["lang"] = lang_code
widget.lang_code = lang_code widget.lang_code = lang_code
widget.lang_name = lang_name widget.lang_name = lang_name
def decompress(self, value: LocalizedValue) -> List[str]: def decompress(self, value: LocalizedValue) -> List[str]:
"""Decompresses the specified value so """Decompresses the specified value so it can be spread over the
it can be spread over the internal widgets. internal widgets.
Arguments: Arguments:
value: value:
@ -61,56 +61,62 @@ class LocalizedFieldWidget(forms.MultiWidget):
if not isinstance(value, list): if not isinstance(value, list):
value = self.decompress(value) value = self.decompress(value)
final_attrs = context['widget']['attrs'] final_attrs = context["widget"]["attrs"]
input_type = final_attrs.pop('type', None) input_type = final_attrs.pop("type", None)
id_ = final_attrs.get('id') id_ = final_attrs.get("id")
subwidgets = [] subwidgets = []
for i, widget in enumerate(self.widgets): for i, widget in enumerate(self.widgets):
if input_type is not None: if input_type is not None:
widget.input_type = input_type widget.input_type = input_type
widget_name = '%s_%s' % (name, i) widget_name = "%s_%s" % (name, i)
try: try:
widget_value = value[i] widget_value = value[i]
except IndexError: except IndexError:
widget_value = None widget_value = None
if id_: if id_:
widget_attrs = final_attrs.copy() widget_attrs = final_attrs.copy()
widget_attrs['id'] = '%s_%s' % (id_, i) widget_attrs["id"] = "%s_%s" % (id_, i)
else: else:
widget_attrs = final_attrs widget_attrs = final_attrs
widget_attrs = self.build_widget_attrs(widget, widget_value, widget_attrs) widget_attrs = self.build_widget_attrs(
widget_context = widget.get_context(widget_name, widget_value, widget_attrs)['widget'] widget, widget_value, widget_attrs
widget_context.update(dict( )
lang_code=widget.lang_code, widget_context = widget.get_context(
lang_name=widget.lang_name widget_name, widget_value, widget_attrs
)) )["widget"]
widget_context.update(
dict(lang_code=widget.lang_code, lang_name=widget.lang_name)
)
subwidgets.append(widget_context) subwidgets.append(widget_context)
context['widget']['subwidgets'] = subwidgets context["widget"]["subwidgets"] = subwidgets
return context return context
@staticmethod @staticmethod
def build_widget_attrs(widget, value, attrs): def build_widget_attrs(widget, value, attrs):
attrs = dict(attrs) # Copy attrs to avoid modifying the argument. attrs = dict(attrs) # Copy attrs to avoid modifying the argument.
if (not widget.use_required_attribute(value) or not widget.is_required) \ if (
and 'required' in attrs: not widget.use_required_attribute(value) or not widget.is_required
del attrs['required'] ) and "required" in attrs:
del attrs["required"]
return attrs return attrs
class LocalizedCharFieldWidget(LocalizedFieldWidget): class LocalizedCharFieldWidget(LocalizedFieldWidget):
"""Widget that has an input box for every language.""" """Widget that has an input box for every language."""
widget = forms.TextInput widget = forms.TextInput
class LocalizedFileWidget(LocalizedFieldWidget): class LocalizedFileWidget(LocalizedFieldWidget):
"""Widget that has an file input box for every language.""" """Widget that has an file input box for every language."""
widget = forms.ClearableFileInput widget = forms.ClearableFileInput
class AdminLocalizedFieldWidget(LocalizedFieldWidget): class AdminLocalizedFieldWidget(LocalizedFieldWidget):
template_name = 'localized_fields/admin/widget.html' template_name = "localized_fields/admin/widget.html"
widget = widgets.AdminTextareaWidget widget = widgets.AdminTextareaWidget

30
setup.py
View File

@ -35,17 +35,17 @@ with open(
setup( setup(
name='django-localized-fields', name="django-localized-fields",
version='6.0b1', version="6.0b1",
packages=find_packages(exclude=['tests']), packages=find_packages(exclude=["tests"]),
include_package_data=True, include_package_data=True,
license='MIT License', license="MIT License",
description='Implementation of localized model fields using PostgreSQL HStore fields.', description="Implementation of localized model fields using PostgreSQL HStore fields.",
long_description=README, long_description=README,
url='https://github.com/SectorLabs/django-localized-fields', url="https://github.com/SectorLabs/django-localized-fields",
author='Sector Labs', author="Sector Labs",
author_email='open-source@sectorlabs.ro', author_email="open-source@sectorlabs.ro",
keywords=['django', 'localized', 'language', 'models', 'fields'], keywords=["django", "localized", "language", "models", "fields"],
classifiers=[ classifiers=[
"Environment :: Web Environment", "Environment :: Web Environment",
"Framework :: Django", "Framework :: Django",
@ -77,11 +77,19 @@ setup(
"localized_fields", "localized_fields",
"tests", "tests",
], ],
["autopep8", "-i", "-r", "setup.py", "localized_fields", "tests"], [
"autopep8",
"-i",
"-r",
"setup.py",
"localized_fields",
"tests",
],
], ],
), ),
"format": create_command( "format": create_command(
"Formats the code", [["black", "setup.py", "localized_fields", "tests"]] "Formats the code",
[["black", "setup.py", "localized_fields", "tests"]],
), ),
"format_verify": create_command( "format_verify": create_command(
"Checks if the code is auto-formatted", "Checks if the code is auto-formatted",

5
tests/data.py
View File

@ -2,12 +2,11 @@ from django.conf import settings
def get_init_values() -> dict: def get_init_values() -> dict:
"""Gets a test dictionary containing a key """Gets a test dictionary containing a key for every language."""
for every language."""
keys = {} keys = {}
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
keys[lang_code] = 'value in %s' % lang_name keys[lang_code] = "value in %s" % lang_name
return keys return keys

16
tests/fake_model.py
View File

@ -1,20 +1,20 @@
import uuid import uuid
from django.contrib.postgres.operations import HStoreExtension
from django.db import connection, migrations from django.db import connection, migrations
from django.db.migrations.executor import MigrationExecutor from django.db.migrations.executor import MigrationExecutor
from django.contrib.postgres.operations import HStoreExtension
from localized_fields.models import LocalizedModel from localized_fields.models import LocalizedModel
def define_fake_model(fields=None, model_base=LocalizedModel, meta_options={}): def define_fake_model(fields=None, model_base=LocalizedModel, meta_options={}):
name = str(uuid.uuid4()).replace('-', '')[:8] name = str(uuid.uuid4()).replace("-", "")[:8]
attributes = { attributes = {
'app_label': 'tests', "app_label": "tests",
'__module__': __name__, "__module__": __name__,
'__name__': name, "__name__": name,
'Meta': type('Meta', (object,), meta_options) "Meta": type("Meta", (object,), meta_options),
} }
if fields: if fields:
@ -30,7 +30,6 @@ def get_fake_model(fields=None, model_base=LocalizedModel, meta_options={}):
model = define_fake_model(fields, model_base, meta_options) model = define_fake_model(fields, model_base, meta_options)
class TestProject: class TestProject:
def clone(self, *_args, **_kwargs): def clone(self, *_args, **_kwargs):
return self return self
@ -44,7 +43,8 @@ def get_fake_model(fields=None, model_base=LocalizedModel, meta_options={}):
with connection.schema_editor() as schema_editor: with connection.schema_editor() as schema_editor:
migration_executor = MigrationExecutor(schema_editor.connection) migration_executor = MigrationExecutor(schema_editor.connection)
migration_executor.apply_migration( migration_executor.apply_migration(
TestProject(), TestMigration('eh', 'postgres_extra')) TestProject(), TestMigration("eh", "postgres_extra")
)
schema_editor.create_model(model) schema_editor.create_model(model)

46
tests/test_admin.py
View File

@ -4,9 +4,8 @@ from django.contrib.admin.checks import check_admin_app
from django.db import models from django.db import models
from django.test import TestCase from django.test import TestCase
from localized_fields.fields import LocalizedField
from localized_fields.admin import LocalizedFieldsAdminMixin from localized_fields.admin import LocalizedFieldsAdminMixin
from localized_fields.fields import LocalizedField
from tests.fake_model import get_fake_model from tests.fake_model import get_fake_model
@ -22,16 +21,13 @@ class LocalizedFieldsAdminMixinTestCase(TestCase):
super(LocalizedFieldsAdminMixinTestCase, cls).setUpClass() super(LocalizedFieldsAdminMixinTestCase, cls).setUpClass()
cls.TestRelModel = get_fake_model( cls.TestRelModel = get_fake_model({"description": LocalizedField()})
{
'description': LocalizedField()
}
)
cls.TestModel = get_fake_model( cls.TestModel = get_fake_model(
{ {
'title': LocalizedField(), "title": LocalizedField(),
'rel': models.ForeignKey(cls.TestRelModel, "rel": models.ForeignKey(
on_delete=models.CASCADE) cls.TestRelModel, on_delete=models.CASCADE
),
} }
) )
@ -43,8 +39,8 @@ class LocalizedFieldsAdminMixinTestCase(TestCase):
@classmethod @classmethod
def test_model_admin(cls): def test_model_admin(cls):
"""Tests whether :see:LocalizedFieldsAdminMixin """Tests whether :see:LocalizedFieldsAdminMixin mixin are works with
mixin are works with admin.ModelAdmin""" admin.ModelAdmin."""
@admin.register(cls.TestModel) @admin.register(cls.TestModel)
class TestModelAdmin(LocalizedFieldsAdminMixin, admin.ModelAdmin): class TestModelAdmin(LocalizedFieldsAdminMixin, admin.ModelAdmin):
@ -54,34 +50,32 @@ class LocalizedFieldsAdminMixinTestCase(TestCase):
@classmethod @classmethod
def test_stackedmodel_admin(cls): def test_stackedmodel_admin(cls):
"""Tests whether :see:LocalizedFieldsAdminMixin mixin are works """Tests whether :see:LocalizedFieldsAdminMixin mixin are works with
with admin.StackedInline""" admin.StackedInline."""
class TestModelStackedInline(LocalizedFieldsAdminMixin, class TestModelStackedInline(
admin.StackedInline): LocalizedFieldsAdminMixin, admin.StackedInline
):
model = cls.TestModel model = cls.TestModel
@admin.register(cls.TestRelModel) @admin.register(cls.TestRelModel)
class TestRelModelAdmin(admin.ModelAdmin): class TestRelModelAdmin(admin.ModelAdmin):
inlines = [ inlines = [TestModelStackedInline]
TestModelStackedInline,
]
assert len(check_admin_app(apps.get_app_configs())) == 0 assert len(check_admin_app(apps.get_app_configs())) == 0
@classmethod @classmethod
def test_tabularmodel_admin(cls): def test_tabularmodel_admin(cls):
"""Tests whether :see:LocalizedFieldsAdminMixin mixin are works """Tests whether :see:LocalizedFieldsAdminMixin mixin are works with
with admin.TabularInline""" admin.TabularInline."""
class TestModelTabularInline(LocalizedFieldsAdminMixin, class TestModelTabularInline(
admin.TabularInline): LocalizedFieldsAdminMixin, admin.TabularInline
):
model = cls.TestModel model = cls.TestModel
@admin.register(cls.TestRelModel) @admin.register(cls.TestRelModel)
class TestRelModelAdmin(admin.ModelAdmin): class TestRelModelAdmin(admin.ModelAdmin):
inlines = [ inlines = [TestModelTabularInline]
TestModelTabularInline,
]
assert len(check_admin_app(apps.get_app_configs())) == 0 assert len(check_admin_app(apps.get_app_configs())) == 0

29
tests/test_bleach_field.py
View File

@ -25,8 +25,8 @@ class LocalizedBleachFieldTestCase(TestCase):
"""Tests the :see:LocalizedBleachField class.""" """Tests the :see:LocalizedBleachField class."""
def test_pre_save(self): def test_pre_save(self):
"""Tests whether the :see:pre_save function """Tests whether the :see:pre_save function bleaches all values in a
bleaches all values in a :see:LocalizedValue.""" :see:LocalizedValue."""
value = self._get_test_value() value = self._get_test_value()
model, field = self._get_test_model(value) model, field = self._get_test_model(value)
@ -35,8 +35,8 @@ class LocalizedBleachFieldTestCase(TestCase):
self._validate(value, bleached_value) self._validate(value, bleached_value)
def test_pre_save_none(self): def test_pre_save_none(self):
"""Tests whether the :see:pre_save function """Tests whether the :see:pre_save function works properly when
works properly when specifying :see:None.""" specifying :see:None."""
model, field = self._get_test_model(None) model, field = self._get_test_model(None)
@ -44,9 +44,8 @@ class LocalizedBleachFieldTestCase(TestCase):
assert not bleached_value assert not bleached_value
def test_pre_save_none_values(self): def test_pre_save_none_values(self):
"""Tests whether the :see:pre_save function """Tests whether the :see:pre_save function works properly when one of
works properly when one of the languages has the languages has no text and is None."""
no text and is None."""
value = self._get_test_value() value = self._get_test_value()
value.set(settings.LANGUAGE_CODE, None) value.set(settings.LANGUAGE_CODE, None)
@ -58,14 +57,13 @@ class LocalizedBleachFieldTestCase(TestCase):
@staticmethod @staticmethod
def _get_test_model(value): def _get_test_model(value):
"""Gets a test model and a artifically """Gets a test model and a artifically constructed
constructed :see:LocalizedBleachField :see:LocalizedBleachField instance to test with."""
instance to test with."""
model = TestModel(value) model = TestModel(value)
field = LocalizedBleachField() field = LocalizedBleachField()
field.attname = 'value' field.attname = "value"
return model, field return model, field
@staticmethod @staticmethod
@ -75,14 +73,14 @@ class LocalizedBleachFieldTestCase(TestCase):
value = LocalizedValue() value = LocalizedValue()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
value.set(lang_code, '<script>%s</script>' % lang_name) value.set(lang_code, "<script>%s</script>" % lang_name)
return value return value
@staticmethod @staticmethod
def _validate(non_bleached_value, bleached_value): def _validate(non_bleached_value, bleached_value):
"""Validates whether the specified non-bleached """Validates whether the specified non-bleached value ended up being
value ended up being correctly bleached. correctly bleached.
Arguments: Arguments:
non_bleached_value: non_bleached_value:
@ -98,8 +96,7 @@ class LocalizedBleachFieldTestCase(TestCase):
continue continue
expected_value = bleach.clean( expected_value = bleach.clean(
non_bleached_value.get(lang_code), non_bleached_value.get(lang_code), get_bleach_default_options()
get_bleach_default_options()
) )
assert bleached_value.get(lang_code) == expected_value assert bleached_value.get(lang_code) == expected_value

32
tests/test_bulk.py
View File

@ -7,26 +7,34 @@ from .fake_model import get_fake_model
class LocalizedBulkTestCase(TestCase): class LocalizedBulkTestCase(TestCase):
"""Tests bulk operations with data structures provided """Tests bulk operations with data structures provided by the django-
by the django-localized-fields library.""" localized-fields library."""
@staticmethod @staticmethod
def test_localized_bulk_insert(): def test_localized_bulk_insert():
"""Tests whether bulk inserts work properly when using """Tests whether bulk inserts work properly when using a
a :see:LocalizedUniqueSlugField in the model.""" :see:LocalizedUniqueSlugField in the model."""
model = get_fake_model( model = get_fake_model(
{ {
'name': LocalizedField(), "name": LocalizedField(),
'slug': LocalizedUniqueSlugField(populate_from='name', include_time=True), "slug": LocalizedUniqueSlugField(
'score': models.IntegerField() populate_from="name", include_time=True
),
"score": models.IntegerField(),
} }
) )
to_create = [ to_create = [
model(name={'en': 'english name 1', 'ro': 'romanian name 1'}, score=1), model(
model(name={'en': 'english name 2', 'ro': 'romanian name 2'}, score=2), name={"en": "english name 1", "ro": "romanian name 1"}, score=1
model(name={'en': 'english name 3', 'ro': 'romanian name 3'}, score=3) ),
model(
name={"en": "english name 2", "ro": "romanian name 2"}, score=2
),
model(
name={"en": "english name 3", "ro": "romanian name 3"}, score=3
),
] ]
model.objects.bulk_create(to_create) model.objects.bulk_create(to_create)
@ -34,9 +42,7 @@ class LocalizedBulkTestCase(TestCase):
for obj in to_create: for obj in to_create:
obj_db = model.objects.filter( obj_db = model.objects.filter(
name__en=obj.name.en, name__en=obj.name.en, name__ro=obj.name.ro, score=obj.score
name__ro=obj.name.ro,
score=obj.score
).first() ).first()
assert obj_db assert obj_db

52
tests/test_expressions.py
View File

@ -1,12 +1,12 @@
from django.test import TestCase
from django.db import models
from django.utils import translation
from django.conf import settings from django.conf import settings
from django.contrib.postgres.aggregates import ArrayAgg from django.contrib.postgres.aggregates import ArrayAgg
from django.db import models
from django.test import TestCase
from django.utils import translation
from localized_fields.expressions import LocalizedRef
from localized_fields.fields import LocalizedField from localized_fields.fields import LocalizedField
from localized_fields.value import LocalizedValue from localized_fields.value import LocalizedValue
from localized_fields.expressions import LocalizedRef
from .fake_model import get_fake_model from .fake_model import get_fake_model
@ -24,15 +24,17 @@ class LocalizedExpressionsTestCase(TestCase):
super(LocalizedExpressionsTestCase, cls).setUpClass() super(LocalizedExpressionsTestCase, cls).setUpClass()
cls.TestModel1 = get_fake_model( cls.TestModel1 = get_fake_model(
{ {"name": models.CharField(null=False, blank=False, max_length=255)}
'name': models.CharField(null=False, blank=False, max_length=255),
}
) )
cls.TestModel2 = get_fake_model( cls.TestModel2 = get_fake_model(
{ {
'text': LocalizedField(), "text": LocalizedField(),
'other': models.ForeignKey(cls.TestModel1, related_name='features', on_delete=models.CASCADE) "other": models.ForeignKey(
cls.TestModel1,
related_name="features",
on_delete=models.CASCADE,
),
} }
) )
@ -40,24 +42,28 @@ class LocalizedExpressionsTestCase(TestCase):
def test_localized_ref(cls): def test_localized_ref(cls):
"""Tests whether the :see:LocalizedRef expression properly works.""" """Tests whether the :see:LocalizedRef expression properly works."""
obj = cls.TestModel1.objects.create(name='bla bla') obj = cls.TestModel1.objects.create(name="bla bla")
for i in range(0, 10): for i in range(0, 10):
cls.TestModel2.objects.create( cls.TestModel2.objects.create(
text=LocalizedValue(dict(en='text_%d_en' % i, ro='text_%d_ro' % i, nl='text_%d_nl' % i)), text=LocalizedValue(
other=obj dict(
en="text_%d_en" % i,
ro="text_%d_ro" % i,
nl="text_%d_nl" % i,
)
),
other=obj,
) )
def create_queryset(ref): def create_queryset(ref):
return ( return cls.TestModel1.objects.annotate(mytexts=ref).values_list(
cls.TestModel1.objects "mytexts", flat=True
.annotate(mytexts=ref)
.values_list('mytexts', flat=True)
) )
# assert that it properly selects the currently active language # assert that it properly selects the currently active language
for lang_code, _ in settings.LANGUAGES: for lang_code, _ in settings.LANGUAGES:
translation.activate(lang_code) translation.activate(lang_code)
queryset = create_queryset(LocalizedRef('features__text')) queryset = create_queryset(LocalizedRef("features__text"))
for index, value in enumerate(queryset): for index, value in enumerate(queryset):
assert translation.get_language() in value assert translation.get_language() in value
@ -66,19 +72,21 @@ class LocalizedExpressionsTestCase(TestCase):
# ensure that the default language is used in case no # ensure that the default language is used in case no
# language is active at all # language is active at all
translation.deactivate_all() translation.deactivate_all()
queryset = create_queryset(LocalizedRef('features__text')) queryset = create_queryset(LocalizedRef("features__text"))
for index, value in enumerate(queryset): for index, value in enumerate(queryset):
assert settings.LANGUAGE_CODE in value assert settings.LANGUAGE_CODE in value
assert str(index) in value assert str(index) in value
# ensures that overriding the language works properly # ensures that overriding the language works properly
queryset = create_queryset(LocalizedRef('features__text', 'ro')) queryset = create_queryset(LocalizedRef("features__text", "ro"))
for index, value in enumerate(queryset): for index, value in enumerate(queryset):
assert 'ro' in value assert "ro" in value
assert str(index) in value assert str(index) in value
# ensures that using this in combination with ArrayAgg works properly # ensures that using this in combination with ArrayAgg works properly
queryset = create_queryset(ArrayAgg(LocalizedRef('features__text', 'ro'))).first() queryset = create_queryset(
ArrayAgg(LocalizedRef("features__text", "ro"))
).first()
assert isinstance(queryset, list) assert isinstance(queryset, list)
for value in queryset: for value in queryset:
assert 'ro' in value assert "ro" in value

138
tests/test_field.py
View File

@ -18,8 +18,8 @@ class LocalizedFieldTestCase(TestCase):
@staticmethod @staticmethod
def test_init(): def test_init():
"""Tests whether the :see:__init__ function """Tests whether the :see:__init__ function correctly handles
correctly handles parameters""" parameters."""
field = LocalizedField(blank=True) field = LocalizedField(blank=True)
assert field.required == [] assert field.required == []
@ -28,16 +28,17 @@ class LocalizedFieldTestCase(TestCase):
assert field.required == [settings.LANGUAGE_CODE] assert field.required == [settings.LANGUAGE_CODE]
field = LocalizedField(required=True) field = LocalizedField(required=True)
assert field.required == [lang_code for lang_code, _ in assert field.required == [
settings.LANGUAGES] lang_code for lang_code, _ in settings.LANGUAGES
]
field = LocalizedField(required=False) field = LocalizedField(required=False)
assert field.required == [] assert field.required == []
@staticmethod @staticmethod
def test_from_db_value(): def test_from_db_value():
"""Tests whether the :see:from_db_value function """Tests whether the :see:from_db_value function produces the expected
produces the expected :see:LocalizedValue.""" :see:LocalizedValue."""
input_data = get_init_values() input_data = get_init_values()
localized_value = LocalizedField().from_db_value(input_data) localized_value = LocalizedField().from_db_value(input_data)
@ -47,8 +48,8 @@ class LocalizedFieldTestCase(TestCase):
@staticmethod @staticmethod
def test_from_db_value_none(): def test_from_db_value_none():
"""Tests whether the :see:from_db_value function """Tests whether the :see:from_db_value function correctly handles None
correctly handles None values.""" values."""
localized_value = LocalizedField().from_db_value(None) localized_value = LocalizedField().from_db_value(None)
@ -56,9 +57,8 @@ class LocalizedFieldTestCase(TestCase):
assert localized_value.get(lang_code) is None assert localized_value.get(lang_code) is None
def test_from_db_value_none_return_none(self): def test_from_db_value_none_return_none(self):
"""Tests whether the :see:from_db_value function """Tests whether the :see:from_db_value function correctly handles None
correctly handles None values when LOCALIZED_FIELDS_EXPERIMENTAL values when LOCALIZED_FIELDS_EXPERIMENTAL is set to True."""
is set to True."""
with self.settings(LOCALIZED_FIELDS_EXPERIMENTAL=True): with self.settings(LOCALIZED_FIELDS_EXPERIMENTAL=True):
localized_value = LocalizedField.from_db_value(None) localized_value = LocalizedField.from_db_value(None)
@ -67,8 +67,8 @@ class LocalizedFieldTestCase(TestCase):
@staticmethod @staticmethod
def test_to_python(): def test_to_python():
"""Tests whether the :see:to_python function """Tests whether the :see:to_python function produces the expected
produces the expected :see:LocalizedValue.""" :see:LocalizedValue."""
input_data = get_init_values() input_data = get_init_values()
localized_value = LocalizedField().to_python(input_data) localized_value = LocalizedField().to_python(input_data)
@ -78,17 +78,16 @@ class LocalizedFieldTestCase(TestCase):
@staticmethod @staticmethod
def test_to_python_non_json(): def test_to_python_non_json():
"""Tests whether the :see:to_python function """Tests whether the :see:to_python function properly handles a string
properly handles a string that is not JSON.""" that is not JSON."""
localized_value = LocalizedField().to_python('my value') localized_value = LocalizedField().to_python("my value")
assert localized_value.get() == 'my value' assert localized_value.get() == "my value"
@staticmethod @staticmethod
def test_to_python_none(): def test_to_python_none():
"""Tests whether the :see:to_python function """Tests whether the :see:to_python function produces the expected
produces the expected :see:LocalizedValue :see:LocalizedValue instance when it is passes None."""
instance when it is passes None."""
localized_value = LocalizedField().to_python(None) localized_value = LocalizedField().to_python(None)
assert localized_value assert localized_value
@ -98,9 +97,8 @@ class LocalizedFieldTestCase(TestCase):
@staticmethod @staticmethod
def test_to_python_non_dict(): def test_to_python_non_dict():
"""Tests whether the :see:to_python function produces """Tests whether the :see:to_python function produces the expected
the expected :see:LocalizedValue when it is :see:LocalizedValue when it is passed a non-dictionary value."""
passed a non-dictionary value."""
localized_value = LocalizedField().to_python(list()) localized_value = LocalizedField().to_python(list())
assert localized_value assert localized_value
@ -110,9 +108,8 @@ class LocalizedFieldTestCase(TestCase):
@staticmethod @staticmethod
def test_to_python_str(): def test_to_python_str():
"""Tests whether the :see:to_python function produces """Tests whether the :see:to_python function produces the expected
the expected :see:LocalizedValue when it is :see:LocalizedValue when it is passed serialized string value."""
passed serialized string value."""
serialized_str = json.dumps(get_init_values()) serialized_str = json.dumps(get_init_values())
localized_value = LocalizedField().to_python(serialized_str) localized_value = LocalizedField().to_python(serialized_str)
@ -124,8 +121,8 @@ class LocalizedFieldTestCase(TestCase):
@staticmethod @staticmethod
def test_get_prep_value(): def test_get_prep_value():
""""Tests whether the :see:get_prep_value function """"Tests whether the :see:get_prep_value function produces the
produces the expected dictionary.""" expected dictionary."""
input_data = get_init_values() input_data = get_init_values()
localized_value = LocalizedValue(input_data) localized_value = LocalizedValue(input_data)
@ -138,25 +135,24 @@ class LocalizedFieldTestCase(TestCase):
@staticmethod @staticmethod
def test_get_prep_value_none(): def test_get_prep_value_none():
"""Tests whether the :see:get_prep_value function """Tests whether the :see:get_prep_value function produces the expected
produces the expected output when it is passed None.""" output when it is passed None."""
output_data = LocalizedField().get_prep_value(None) output_data = LocalizedField().get_prep_value(None)
assert not output_data assert not output_data
@staticmethod @staticmethod
def test_get_prep_value_no_localized_value(): def test_get_prep_value_no_localized_value():
"""Tests whether the :see:get_prep_value function """Tests whether the :see:get_prep_value function produces the expected
produces the expected output when it is passed a output when it is passed a non-LocalizedValue value."""
non-LocalizedValue value."""
output_data = LocalizedField().get_prep_value(['huh']) output_data = LocalizedField().get_prep_value(["huh"])
assert not output_data assert not output_data
def test_get_prep_value_clean(self): def test_get_prep_value_clean(self):
"""Tests whether the :see:get_prep_value produces """Tests whether the :see:get_prep_value produces None as the output
None as the output when it is passed an empty, but when it is passed an empty, but valid LocalizedValue value but, only
valid LocalizedValue value but, only when null=True.""" when null=True."""
localized_value = LocalizedValue() localized_value = LocalizedValue()
@ -165,17 +161,14 @@ class LocalizedFieldTestCase(TestCase):
assert not LocalizedField(null=True).get_prep_value(localized_value) assert not LocalizedField(null=True).get_prep_value(localized_value)
assert not LocalizedField().clean(None) assert not LocalizedField().clean(None)
assert not LocalizedField().clean(['huh']) assert not LocalizedField().clean(["huh"])
@staticmethod @staticmethod
def test_formfield(): def test_formfield():
"""Tests whether the :see:formfield function """Tests whether the :see:formfield function correctly returns a valid
correctly returns a valid form.""" form."""
assert isinstance( assert isinstance(LocalizedField().formfield(), LocalizedFieldForm)
LocalizedField().formfield(),
LocalizedFieldForm
)
# case optional filling # case optional filling
field = LocalizedField(blank=True, required=[]) field = LocalizedField(blank=True, required=[])
@ -190,7 +183,7 @@ class LocalizedFieldTestCase(TestCase):
assert not field.required assert not field.required
# case required for specific languages # case required for specific languages
required_langs = ['ro', 'nl'] required_langs = ["ro", "nl"]
field = LocalizedField(blank=False, required=required_langs) field = LocalizedField(blank=False, required=required_langs)
assert field.formfield().required assert field.formfield().required
for field in field.formfield().fields: for field in field.formfield().fields:
@ -206,31 +199,31 @@ class LocalizedFieldTestCase(TestCase):
assert field.required assert field.required
def test_descriptor_user_defined_primary_key(self): def test_descriptor_user_defined_primary_key(self):
"""Tests that descriptor works even when primary key is user defined.""" """Tests that descriptor works even when primary key is user
model = get_fake_model(dict( defined."""
slug=models.SlugField(primary_key=True), model = get_fake_model(
title=LocalizedField() dict(
)) slug=models.SlugField(primary_key=True), title=LocalizedField()
)
)
obj = model.objects.create(slug='test', title='test') obj = model.objects.create(slug="test", title="test")
assert obj.title == 'test' assert obj.title == "test"
def test_required_all(self): def test_required_all(self):
"""Tests whether passing required=True properly validates """Tests whether passing required=True properly validates that all
that all languages are filled in.""" languages are filled in."""
model = get_fake_model(dict( model = get_fake_model(dict(title=LocalizedField(required=True)))
title=LocalizedField(required=True)
))
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=dict(ro='romanian', nl='dutch')) model.objects.create(title=dict(ro="romanian", nl="dutch"))
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=dict(nl='dutch')) model.objects.create(title=dict(nl="dutch"))
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=dict(random='random')) model.objects.create(title=dict(random="random"))
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=dict()) model.objects.create(title=dict())
@ -239,28 +232,27 @@ class LocalizedFieldTestCase(TestCase):
model.objects.create(title=None) model.objects.create(title=None)
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title='') model.objects.create(title="")
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=' ') model.objects.create(title=" ")
def test_required_some(self): def test_required_some(self):
"""Tests whether passing an array to required, """Tests whether passing an array to required, properly validates
properly validates whether the specified languages whether the specified languages are marked as required."""
are marked as required."""
model = get_fake_model(dict( model = get_fake_model(
title=LocalizedField(required=['nl', 'ro']) dict(title=LocalizedField(required=["nl", "ro"]))
)) )
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=dict(ro='romanian', nl='dutch')) model.objects.create(title=dict(ro="romanian", nl="dutch"))
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=dict(nl='dutch')) model.objects.create(title=dict(nl="dutch"))
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=dict(random='random')) model.objects.create(title=dict(random="random"))
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=dict()) model.objects.create(title=dict())
@ -269,7 +261,7 @@ class LocalizedFieldTestCase(TestCase):
model.objects.create(title=None) model.objects.create(title=None)
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title='') model.objects.create(title="")
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
model.objects.create(title=' ') model.objects.create(title=" ")

105
tests/test_file_field.py
View File

@ -1,21 +1,21 @@
import json
import os import os
import pickle
import shutil import shutil
import tempfile as sys_tempfile import tempfile as sys_tempfile
import pickle
import json
from django import forms from django import forms
from django.test import TestCase, override_settings
from django.core.files.base import File, ContentFile
from django.core.files import temp as tempfile from django.core.files import temp as tempfile
from django.core.files.base import ContentFile, File
from django.test import TestCase, override_settings
from localized_fields.fields import LocalizedFileField from localized_fields.fields import LocalizedFileField
from localized_fields.value import LocalizedValue
from localized_fields.fields.file_field import LocalizedFieldFile from localized_fields.fields.file_field import LocalizedFieldFile
from localized_fields.forms import LocalizedFileFieldForm from localized_fields.forms import LocalizedFileFieldForm
from localized_fields.value import LocalizedFileValue from localized_fields.value import LocalizedFileValue, LocalizedValue
from localized_fields.widgets import LocalizedFileWidget from localized_fields.widgets import LocalizedFileWidget
from .fake_model import get_fake_model
from .fake_model import get_fake_model
MEDIA_ROOT = sys_tempfile.mkdtemp() MEDIA_ROOT = sys_tempfile.mkdtemp()
@ -30,11 +30,7 @@ class LocalizedFileFieldTestCase(TestCase):
super().setUpClass() super().setUpClass()
cls.FileFieldModel = get_fake_model( cls.FileFieldModel = get_fake_model({"file": LocalizedFileField()})
{
'file': LocalizedFileField(),
}
)
if not os.path.isdir(MEDIA_ROOT): if not os.path.isdir(MEDIA_ROOT):
os.makedirs(MEDIA_ROOT) os.makedirs(MEDIA_ROOT)
@ -45,48 +41,49 @@ class LocalizedFileFieldTestCase(TestCase):
@classmethod @classmethod
def test_assign(cls): def test_assign(cls):
"""Tests whether the :see:LocalizedFileValueDescriptor works properly""" """Tests whether the :see:LocalizedFileValueDescriptor works
properly."""
temp_file = tempfile.NamedTemporaryFile(dir=MEDIA_ROOT) temp_file = tempfile.NamedTemporaryFile(dir=MEDIA_ROOT)
instance = cls.FileFieldModel() instance = cls.FileFieldModel()
instance.file = {'en': temp_file.name} instance.file = {"en": temp_file.name}
assert isinstance(instance.file.en, LocalizedFieldFile) assert isinstance(instance.file.en, LocalizedFieldFile)
assert instance.file.en.name == temp_file.name assert instance.file.en.name == temp_file.name
field_dump = pickle.dumps(instance.file) field_dump = pickle.dumps(instance.file)
instance = cls.FileFieldModel() instance = cls.FileFieldModel()
instance.file = pickle.loads(field_dump) instance.file = pickle.loads(field_dump)
assert instance.file.en.field == instance._meta.get_field('file') assert instance.file.en.field == instance._meta.get_field("file")
assert instance.file.en.instance == instance assert instance.file.en.instance == instance
assert isinstance(instance.file.en, LocalizedFieldFile) assert isinstance(instance.file.en, LocalizedFieldFile)
instance = cls.FileFieldModel() instance = cls.FileFieldModel()
instance.file = {'en': ContentFile("test", "testfilename")} instance.file = {"en": ContentFile("test", "testfilename")}
assert isinstance(instance.file.en, LocalizedFieldFile) assert isinstance(instance.file.en, LocalizedFieldFile)
assert instance.file.en.name == "testfilename" assert instance.file.en.name == "testfilename"
another_instance = cls.FileFieldModel() another_instance = cls.FileFieldModel()
another_instance.file = {'ro': instance.file.en} another_instance.file = {"ro": instance.file.en}
assert another_instance == another_instance.file.ro.instance assert another_instance == another_instance.file.ro.instance
assert another_instance.file.ro.lang == 'ro' assert another_instance.file.ro.lang == "ro"
@classmethod @classmethod
def test_save_form_data(cls): def test_save_form_data(cls):
"""Tests whether the :see:save_form_data function correctly set """Tests whether the :see:save_form_data function correctly set a valid
a valid value.""" value."""
instance = cls.FileFieldModel() instance = cls.FileFieldModel()
data = LocalizedFileValue({'en': False}) data = LocalizedFileValue({"en": False})
instance._meta.get_field('file').save_form_data(instance, data) instance._meta.get_field("file").save_form_data(instance, data)
assert instance.file.en == '' assert instance.file.en == ""
@classmethod @classmethod
def test_pre_save(cls): def test_pre_save(cls):
"""Tests whether the :see:pre_save function works properly.""" """Tests whether the :see:pre_save function works properly."""
instance = cls.FileFieldModel() instance = cls.FileFieldModel()
instance.file = {'en': ContentFile("test", "testfilename")} instance.file = {"en": ContentFile("test", "testfilename")}
instance._meta.get_field('file').pre_save(instance, False) instance._meta.get_field("file").pre_save(instance, False)
assert instance.file.en._committed is True assert instance.file.en._committed is True
@classmethod @classmethod
@ -99,8 +96,8 @@ class LocalizedFileFieldTestCase(TestCase):
# Calling delete on an unset FileField should not call the file deletion # Calling delete on an unset FileField should not call the file deletion
# process, but fail silently # process, but fail silently
instance.file.en.delete() instance.file.en.delete()
instance.file.en.save('testfilename', temp_file) instance.file.en.save("testfilename", temp_file)
assert instance.file.en.name == 'testfilename' assert instance.file.en.name == "testfilename"
instance.file.en.delete() instance.file.en.delete()
assert instance.file.en.name is None assert instance.file.en.name is None
@ -110,27 +107,29 @@ class LocalizedFileFieldTestCase(TestCase):
works correctly.""" works correctly."""
instance = cls.FileFieldModel() instance = cls.FileFieldModel()
field = instance._meta.get_field('file') field = instance._meta.get_field("file")
field.upload_to = '{lang}/' field.upload_to = "{lang}/"
filename = field.generate_filename(instance, 'test', 'en') filename = field.generate_filename(instance, "test", "en")
assert filename == 'en/test' assert filename == "en/test"
field.upload_to = lambda instance, filename, lang: \ field.upload_to = lambda instance, filename, lang: "%s_%s" % (
'%s_%s' % (lang, filename) lang,
filename = field.generate_filename(instance, 'test', 'en') filename,
assert filename == 'en_test' )
filename = field.generate_filename(instance, "test", "en")
assert filename == "en_test"
@classmethod @classmethod
@override_settings(LANGUAGES=(('en', 'English'),)) @override_settings(LANGUAGES=(("en", "English"),))
def test_value_to_string(cls): def test_value_to_string(cls):
"""Tests whether the :see:LocalizedFileField """Tests whether the :see:LocalizedFileField class's
class's :see:value_to_string function works properly.""" :see:value_to_string function works properly."""
temp_file = File(tempfile.NamedTemporaryFile()) temp_file = File(tempfile.NamedTemporaryFile())
instance = cls.FileFieldModel() instance = cls.FileFieldModel()
field = cls.FileFieldModel._meta.get_field('file') field = cls.FileFieldModel._meta.get_field("file")
field.upload_to = '' field.upload_to = ""
instance.file.en.save('testfilename', temp_file) instance.file.en.save("testfilename", temp_file)
expected_value_to_string = json.dumps({'en': 'testfilename'}) expected_value_to_string = json.dumps({"en": "testfilename"})
assert field.value_to_string(instance) == expected_value_to_string assert field.value_to_string(instance) == expected_value_to_string
@staticmethod @staticmethod
@ -138,15 +137,15 @@ class LocalizedFileFieldTestCase(TestCase):
"""Tests whether the :see:get_prep_value function returns correctly """Tests whether the :see:get_prep_value function returns correctly
value.""" value."""
value = LocalizedValue({'en': None}) value = LocalizedValue({"en": None})
assert LocalizedFileField().get_prep_value(None) is None assert LocalizedFileField().get_prep_value(None) is None
assert isinstance(LocalizedFileField().get_prep_value(value), dict) assert isinstance(LocalizedFileField().get_prep_value(value), dict)
assert LocalizedFileField().get_prep_value(value)['en'] == '' assert LocalizedFileField().get_prep_value(value)["en"] == ""
@staticmethod @staticmethod
def test_formfield(): def test_formfield():
"""Tests whether the :see:formfield function correctly returns """Tests whether the :see:formfield function correctly returns a valid
a valid form.""" form."""
form_field = LocalizedFileField().formfield() form_field = LocalizedFileField().formfield()
assert isinstance(form_field, LocalizedFileFieldForm) assert isinstance(form_field, LocalizedFileFieldForm)
@ -155,11 +154,13 @@ class LocalizedFileFieldTestCase(TestCase):
@staticmethod @staticmethod
def test_deconstruct(): def test_deconstruct():
"""Tests whether the :see:LocalizedFileField """Tests whether the :see:LocalizedFileField class's :see:deconstruct
class's :see:deconstruct function works properly.""" function works properly."""
name, path, args, kwargs = LocalizedFileField().deconstruct() name, path, args, kwargs = LocalizedFileField().deconstruct()
assert 'upload_to' in kwargs assert "upload_to" in kwargs
assert 'storage' not in kwargs assert "storage" not in kwargs
name, path, args, kwargs = LocalizedFileField(storage='test').deconstruct() name, path, args, kwargs = LocalizedFileField(
assert 'storage' in kwargs storage="test"
).deconstruct()
assert "storage" in kwargs

14
tests/test_file_field_form.py
View File

@ -16,7 +16,7 @@ class LocalizedFileFieldFormTestCase(TestCase):
with self.assertRaises(ValidationError): with self.assertRaises(ValidationError):
formfield.clean([]) formfield.clean([])
with self.assertRaises(ValidationError): with self.assertRaises(ValidationError):
formfield.clean([], {'en': None}) formfield.clean([], {"en": None})
with self.assertRaises(ValidationError): with self.assertRaises(ValidationError):
formfield.clean("badvalue") formfield.clean("badvalue")
with self.assertRaises(ValidationError): with self.assertRaises(ValidationError):
@ -24,17 +24,17 @@ class LocalizedFileFieldFormTestCase(TestCase):
formfield.clean(value) formfield.clean(value)
formfield = LocalizedFileFieldForm(required=False) formfield = LocalizedFileFieldForm(required=False)
formfield.clean([''] * len(settings.LANGUAGES)) formfield.clean([""] * len(settings.LANGUAGES))
formfield.clean(['', ''], ['', '']) formfield.clean(["", ""], ["", ""])
def test_bound_data(self): def test_bound_data(self):
"""Tests whether the :see:bound_data function is returns correctly """Tests whether the :see:bound_data function is returns correctly
value""" value."""
formfield = LocalizedFileFieldForm() formfield = LocalizedFileFieldForm()
assert formfield.bound_data([''], None) == [''] assert formfield.bound_data([""], None) == [""]
initial = dict([(lang, '') for lang, _ in settings.LANGUAGES]) initial = dict([(lang, "") for lang, _ in settings.LANGUAGES])
value = [None] * len(settings.LANGUAGES) value = [None] * len(settings.LANGUAGES)
expected_value = [''] * len(settings.LANGUAGES) expected_value = [""] * len(settings.LANGUAGES)
assert formfield.bound_data(value, initial) == expected_value assert formfield.bound_data(value, initial) == expected_value

18
tests/test_file_widget.py
View File

@ -9,16 +9,18 @@ class LocalizedFileWidgetTestCase(TestCase):
@staticmethod @staticmethod
def test_get_context(): def test_get_context():
"""Tests whether the :see:get_context correctly """Tests whether the :see:get_context correctly handles 'required'
handles 'required' attribute, separately for each subwidget.""" attribute, separately for each subwidget."""
widget = LocalizedFileWidget() widget = LocalizedFileWidget()
widget.widgets[0].is_required = True widget.widgets[0].is_required = True
widget.widgets[1].is_required = True widget.widgets[1].is_required = True
widget.widgets[2].is_required = False widget.widgets[2].is_required = False
context = widget.get_context(name='test', context = widget.get_context(
value=LocalizedFileValue(dict(en='test')), name="test",
attrs=dict(required=True)) value=LocalizedFileValue(dict(en="test")),
assert 'required' not in context['widget']['subwidgets'][0]['attrs'] attrs=dict(required=True),
assert context['widget']['subwidgets'][1]['attrs']['required'] )
assert 'required' not in context['widget']['subwidgets'][2]['attrs'] assert "required" not in context["widget"]["subwidgets"][0]["attrs"]
assert context["widget"]["subwidgets"][1]["attrs"]["required"]
assert "required" not in context["widget"]["subwidgets"][2]["attrs"]

7
tests/test_form.py
View File

@ -9,8 +9,8 @@ class LocalizedFieldFormTestCase(TestCase):
@staticmethod @staticmethod
def test_init(): def test_init():
"""Tests whether the constructor correctly """Tests whether the constructor correctly creates a field for every
creates a field for every language.""" language."""
# case required for specific language # case required for specific language
form = LocalizedFieldForm(required=[settings.LANGUAGE_CODE]) form = LocalizedFieldForm(required=[settings.LANGUAGE_CODE])
@ -42,8 +42,7 @@ class LocalizedFieldFormTestCase(TestCase):
@staticmethod @staticmethod
def test_compress(): def test_compress():
"""Tests whether the :see:compress function """Tests whether the :see:compress function is working properly."""
is working properly."""
input_value = [lang_name for _, lang_name in settings.LANGUAGES] input_value = [lang_name for _, lang_name in settings.LANGUAGES]
output_value = LocalizedFieldForm().compress(input_value) output_value = LocalizedFieldForm().compress(input_value)

94
tests/test_integer_field.py
View File

@ -1,18 +1,18 @@
from django.test import TestCase
from django.db.utils import IntegrityError
from django.conf import settings from django.conf import settings
from django.db import connection from django.db import connection
from django.db.utils import IntegrityError
from django.test import TestCase
from django.utils import translation from django.utils import translation
from localized_fields.value import LocalizedIntegerValue
from localized_fields.fields import LocalizedIntegerField from localized_fields.fields import LocalizedIntegerField
from localized_fields.value import LocalizedIntegerValue
from .fake_model import get_fake_model from .fake_model import get_fake_model
class LocalizedIntegerFieldTestCase(TestCase): class LocalizedIntegerFieldTestCase(TestCase):
"""Tests whether the :see:LocalizedIntegerField """Tests whether the :see:LocalizedIntegerField and
and :see:LocalizedIntegerValue works properly.""" :see:LocalizedIntegerValue works properly."""
TestModel = None TestModel = None
@ -20,9 +20,7 @@ class LocalizedIntegerFieldTestCase(TestCase):
def setUpClass(cls): def setUpClass(cls):
super().setUpClass() super().setUpClass()
cls.TestModel = get_fake_model({ cls.TestModel = get_fake_model({"score": LocalizedIntegerField()})
'score': LocalizedIntegerField()
})
def test_basic(self): def test_basic(self):
"""Tests the basics of storing integer values.""" """Tests the basics of storing integer values."""
@ -37,8 +35,8 @@ class LocalizedIntegerFieldTestCase(TestCase):
assert obj.score.get(lang_code) == index + 1 assert obj.score.get(lang_code) == index + 1
def test_primary_language_required(self): def test_primary_language_required(self):
"""Tests whether the primary language is required by """Tests whether the primary language is required by default and all
default and all other languages are optiona.""" other languages are optiona."""
# not filling in anything should raise IntegrityError, # not filling in anything should raise IntegrityError,
# the primary language is required # the primary language is required
@ -57,8 +55,8 @@ class LocalizedIntegerFieldTestCase(TestCase):
obj.save() obj.save()
def test_default_value_none(self): def test_default_value_none(self):
"""Tests whether the default value for optional languages """Tests whether the default value for optional languages is
is NoneType.""" NoneType."""
obj = self.TestModel() obj = self.TestModel()
obj.score.set(settings.LANGUAGE_CODE, 1234) obj.score.set(settings.LANGUAGE_CODE, 1234)
@ -71,9 +69,8 @@ class LocalizedIntegerFieldTestCase(TestCase):
assert obj.score.get(lang_code) is None assert obj.score.get(lang_code) is None
def test_translate(self): def test_translate(self):
"""Tests whether casting the value to an integer """Tests whether casting the value to an integer results in the value
results in the value being returned in the currently being returned in the currently active language as an integer."""
active language as an integer."""
obj = self.TestModel() obj = self.TestModel()
for index, (lang_code, _) in enumerate(settings.LANGUAGES): for index, (lang_code, _) in enumerate(settings.LANGUAGES):
@ -87,10 +84,9 @@ class LocalizedIntegerFieldTestCase(TestCase):
assert obj.score.translate() == index + 1 assert obj.score.translate() == index + 1
def test_translate_primary_fallback(self): def test_translate_primary_fallback(self):
"""Tests whether casting the value to an integer """Tests whether casting the value to an integer results in the value
results in the value begin returned in the active begin returned in the active language and falls back to the primary
language and falls back to the primary language language if there is no value in that language."""
if there is no value in that language."""
obj = self.TestModel() obj = self.TestModel()
obj.score.set(settings.LANGUAGE_CODE, 25) obj.score.set(settings.LANGUAGE_CODE, 25)
@ -103,9 +99,8 @@ class LocalizedIntegerFieldTestCase(TestCase):
assert int(obj.score) == 25 assert int(obj.score) == 25
def test_get_default_value(self): def test_get_default_value(self):
"""Tests whether getting the value in a specific """Tests whether getting the value in a specific language properly
language properly returns the specified default returns the specified default in case it is not available."""
in case it is not available."""
obj = self.TestModel() obj = self.TestModel()
obj.score.set(settings.LANGUAGE_CODE, 25) obj.score.set(settings.LANGUAGE_CODE, 25)
@ -115,12 +110,11 @@ class LocalizedIntegerFieldTestCase(TestCase):
assert obj.score.get(secondary_language, 1337) == 1337 assert obj.score.get(secondary_language, 1337) == 1337
def test_completely_optional(self): def test_completely_optional(self):
"""Tests whether having all languages optional """Tests whether having all languages optional works properly."""
works properly."""
model = get_fake_model({ model = get_fake_model(
'score': LocalizedIntegerField(null=True, required=[], blank=True) {"score": LocalizedIntegerField(null=True, required=[], blank=True)}
}) )
obj = model() obj = model()
obj.save() obj.save()
@ -129,19 +123,18 @@ class LocalizedIntegerFieldTestCase(TestCase):
assert getattr(obj.score, lang_code) is None assert getattr(obj.score, lang_code) is None
def test_store_string(self): def test_store_string(self):
"""Tests whether the field properly raises """Tests whether the field properly raises an error when trying to
an error when trying to store a non-integer.""" store a non-integer."""
for lang_code, _ in settings.LANGUAGES: for lang_code, _ in settings.LANGUAGES:
obj = self.TestModel() obj = self.TestModel()
with self.assertRaises(IntegrityError): with self.assertRaises(IntegrityError):
obj.score.set(lang_code, 'haha') obj.score.set(lang_code, "haha")
obj.save() obj.save()
def test_none_if_illegal_value_stored(self): def test_none_if_illegal_value_stored(self):
"""Tests whether None is returned for a language """Tests whether None is returned for a language if the value stored in
if the value stored in the database is not an the database is not an integer."""
integer."""
obj = self.TestModel() obj = self.TestModel()
obj.score.set(settings.LANGUAGE_CODE, 25) obj.score.set(settings.LANGUAGE_CODE, 25)
@ -155,12 +148,15 @@ class LocalizedIntegerFieldTestCase(TestCase):
assert obj.score.get(settings.LANGUAGE_CODE) is None assert obj.score.get(settings.LANGUAGE_CODE) is None
def test_default_value(self): def test_default_value(self):
"""Tests whether a default is properly set """Tests whether a default is properly set when specified."""
when specified."""
model = get_fake_model({ model = get_fake_model(
'score': LocalizedIntegerField(default={settings.LANGUAGE_CODE: 75}) {
}) "score": LocalizedIntegerField(
default={settings.LANGUAGE_CODE: 75}
)
}
)
obj = model.objects.create() obj = model.objects.create()
assert obj.score.get(settings.LANGUAGE_CODE) == 75 assert obj.score.get(settings.LANGUAGE_CODE) == 75
@ -177,16 +173,24 @@ class LocalizedIntegerFieldTestCase(TestCase):
assert obj.score.get(lang_code) is None assert obj.score.get(lang_code) is None
def test_default_value_update(self): def test_default_value_update(self):
"""Tests whether a default is properly set """Tests whether a default is properly set when specified during
when specified during updates.""" updates."""
model = get_fake_model({ model = get_fake_model(
'score': LocalizedIntegerField(default={settings.LANGUAGE_CODE: 75}, null=True) {
}) "score": LocalizedIntegerField(
default={settings.LANGUAGE_CODE: 75}, null=True
)
}
)
obj = model.objects.create(score=LocalizedIntegerValue({settings.LANGUAGE_CODE: 35})) obj = model.objects.create(
score=LocalizedIntegerValue({settings.LANGUAGE_CODE: 35})
)
assert obj.score.get(settings.LANGUAGE_CODE) == 35 assert obj.score.get(settings.LANGUAGE_CODE) == 35
model.objects.update(score=LocalizedIntegerValue({settings.LANGUAGE_CODE: None})) model.objects.update(
score=LocalizedIntegerValue({settings.LANGUAGE_CODE: None})
)
obj.refresh_from_db() obj.refresh_from_db()
assert obj.score.get(settings.LANGUAGE_CODE) == 75 assert obj.score.get(settings.LANGUAGE_CODE) == 75

19
tests/test_lookups.py
View File

@ -12,6 +12,7 @@ from .fake_model import get_fake_model
@override_settings(LOCALIZED_FIELDS_EXPERIMENTAL=True) @override_settings(LOCALIZED_FIELDS_EXPERIMENTAL=True)
class LocalizedLookupsTestCase(TestCase): class LocalizedLookupsTestCase(TestCase):
"""Tests whether localized lookups properly work with.""" """Tests whether localized lookups properly work with."""
TestModel1 = None TestModel1 = None
@classmethod @classmethod
@ -21,31 +22,29 @@ class LocalizedLookupsTestCase(TestCase):
super(LocalizedLookupsTestCase, cls).setUpClass() super(LocalizedLookupsTestCase, cls).setUpClass()
# reload app as setting has changed # reload app as setting has changed
config = apps.get_app_config('localized_fields') config = apps.get_app_config("localized_fields")
config.ready() config.ready()
cls.TestModel = get_fake_model( cls.TestModel = get_fake_model({"text": LocalizedField()})
{
'text': LocalizedField(),
}
)
def test_localized_lookup(self): def test_localized_lookup(self):
"""Tests whether localized lookup properly works.""" """Tests whether localized lookup properly works."""
self.TestModel.objects.create( self.TestModel.objects.create(
text=LocalizedValue(dict(en='text_en', ro='text_ro', nl='text_nl')), text=LocalizedValue(dict(en="text_en", ro="text_ro", nl="text_nl"))
) )
# assert that it properly lookups the currently active language # assert that it properly lookups the currently active language
for lang_code, _ in settings.LANGUAGES: for lang_code, _ in settings.LANGUAGES:
translation.activate(lang_code) translation.activate(lang_code)
assert self.TestModel.objects.filter(text='text_' + lang_code).exists() assert self.TestModel.objects.filter(
text="text_" + lang_code
).exists()
# ensure that the default language is used in case no # ensure that the default language is used in case no
# language is active at all # language is active at all
translation.deactivate_all() translation.deactivate_all()
assert self.TestModel.objects.filter(text='text_en').exists() assert self.TestModel.objects.filter(text="text_en").exists()
# ensure that hstore lookups still work # ensure that hstore lookups still work
assert self.TestModel.objects.filter(text__ro='text_ro').exists() assert self.TestModel.objects.filter(text__ro="text_ro").exists()

30
tests/test_model.py
View File

@ -17,17 +17,12 @@ class LocalizedModelTestCase(TestCase):
super(LocalizedModelTestCase, cls).setUpClass() super(LocalizedModelTestCase, cls).setUpClass()
cls.TestModel = get_fake_model( cls.TestModel = get_fake_model({"title": LocalizedField()})
{
'title': LocalizedField()
}
)
@classmethod @classmethod
def test_defaults(cls): def test_defaults(cls):
"""Tests whether all :see:LocalizedField """Tests whether all :see:LocalizedField fields are assigned an empty
fields are assigned an empty :see:LocalizedValue :see:LocalizedValue instance when the model is instanitiated."""
instance when the model is instanitiated."""
obj = cls.TestModel() obj = cls.TestModel()
@ -35,19 +30,18 @@ class LocalizedModelTestCase(TestCase):
@classmethod @classmethod
def test_model_init_kwargs(cls): def test_model_init_kwargs(cls):
"""Tests whether all :see:LocalizedField """Tests whether all :see:LocalizedField fields are assigned an empty
fields are assigned an empty :see:LocalizedValue :see:LocalizedValue instance when the model is instanitiated."""
instance when the model is instanitiated."""
data = { data = {
'title': { "title": {
'en': 'english_title', "en": "english_title",
'ro': 'romanian_title', "ro": "romanian_title",
'nl': 'dutch_title' "nl": "dutch_title",
} }
} }
obj = cls.TestModel(**data) obj = cls.TestModel(**data)
assert isinstance(obj.title, LocalizedValue) assert isinstance(obj.title, LocalizedValue)
assert obj.title.en == 'english_title' assert obj.title.en == "english_title"
assert obj.title.ro == 'romanian_title' assert obj.title.ro == "romanian_title"
assert obj.title.nl == 'dutch_title' assert obj.title.nl == "dutch_title"

22
tests/test_query_set.py
View File

@ -16,30 +16,24 @@ class LocalizedQuerySetTestCase(TestCase):
super(LocalizedQuerySetTestCase, cls).setUpClass() super(LocalizedQuerySetTestCase, cls).setUpClass()
cls.Model = get_fake_model( cls.Model = get_fake_model({"title": LocalizedField()})
{
'title': LocalizedField(),
}
)
@classmethod @classmethod
def test_assign_raw_dict(cls): def test_assign_raw_dict(cls):
inst = cls.Model() inst = cls.Model()
inst.title = dict(en='Bread', ro='Paine') inst.title = dict(en="Bread", ro="Paine")
inst.save() inst.save()
inst = cls.Model.objects.get(pk=inst.pk) inst = cls.Model.objects.get(pk=inst.pk)
assert inst.title.en == 'Bread' assert inst.title.en == "Bread"
assert inst.title.ro == 'Paine' assert inst.title.ro == "Paine"
@classmethod @classmethod
def test_assign_raw_dict_update(cls): def test_assign_raw_dict_update(cls):
inst = cls.Model.objects.create( inst = cls.Model.objects.create(title=dict(en="Bread", ro="Paine"))
title=dict(en='Bread', ro='Paine'))
cls.Model.objects.update( cls.Model.objects.update(title=dict(en="Beer", ro="Bere"))
title=dict(en='Beer', ro='Bere'))
inst = cls.Model.objects.get(pk=inst.pk) inst = cls.Model.objects.get(pk=inst.pk)
assert inst.title.en == 'Beer' assert inst.title.en == "Beer"
assert inst.title.ro == 'Bere' assert inst.title.ro == "Bere"

159
tests/test_slug_fields.py
View File

@ -1,16 +1,13 @@
import copy import copy
from django import forms from django import forms
from django.db import models
from django.conf import settings from django.conf import settings
from django.test import TestCase from django.db import models
from django.db.utils import IntegrityError from django.db.utils import IntegrityError
from django.test import TestCase
from django.utils.text import slugify from django.utils.text import slugify
from localized_fields.fields import ( from localized_fields.fields import LocalizedField, LocalizedUniqueSlugField
LocalizedField,
LocalizedUniqueSlugField
)
from .fake_model import get_fake_model from .fake_model import get_fake_model
@ -29,23 +26,25 @@ class LocalizedSlugFieldTestCase(TestCase):
cls.Model = get_fake_model( cls.Model = get_fake_model(
{ {
'title': LocalizedField(), "title": LocalizedField(),
'name': models.CharField(max_length=255), "name": models.CharField(max_length=255),
'slug': LocalizedUniqueSlugField(populate_from='title') "slug": LocalizedUniqueSlugField(populate_from="title"),
} }
) )
@staticmethod @staticmethod
def test_unique_slug_with_time(): def test_unique_slug_with_time():
"""Tests whether the primary key is included in """Tests whether the primary key is included in the slug when the
the slug when the 'use_pk' option is enabled.""" 'use_pk' option is enabled."""
title = 'myuniquetitle' title = "myuniquetitle"
PkModel = get_fake_model( PkModel = get_fake_model(
{ {
'title': LocalizedField(), "title": LocalizedField(),
'slug': LocalizedUniqueSlugField(populate_from='title', include_time=True) "slug": LocalizedUniqueSlugField(
populate_from="title", include_time=True
),
} }
) )
@ -53,7 +52,7 @@ class LocalizedSlugFieldTestCase(TestCase):
obj.title.en = title obj.title.en = title
obj.save() obj.save()
assert obj.slug.en.startswith('%s-' % title) assert obj.slug.en.startswith("%s-" % title)
@classmethod @classmethod
def test_uniue_slug_no_change(cls): def test_uniue_slug_no_change(cls):
@ -61,12 +60,14 @@ class LocalizedSlugFieldTestCase(TestCase):
NoChangeSlugModel = get_fake_model( NoChangeSlugModel = get_fake_model(
{ {
'title': LocalizedField(), "title": LocalizedField(),
'slug': LocalizedUniqueSlugField(populate_from='title', include_time=True) "slug": LocalizedUniqueSlugField(
populate_from="title", include_time=True
),
} }
) )
title = 'myuniquetitle' title = "myuniquetitle"
obj = NoChangeSlugModel() obj = NoChangeSlugModel()
obj.title.en = title obj.title.en = title
@ -75,7 +76,7 @@ class LocalizedSlugFieldTestCase(TestCase):
old_slug_en = copy.deepcopy(obj.slug.en) old_slug_en = copy.deepcopy(obj.slug.en)
old_slug_nl = copy.deepcopy(obj.slug.nl) old_slug_nl = copy.deepcopy(obj.slug.nl)
obj.title.nl += 'beer' obj.title.nl += "beer"
obj.save() obj.save()
assert old_slug_en == obj.slug.en assert old_slug_en == obj.slug.en
@ -83,18 +84,20 @@ class LocalizedSlugFieldTestCase(TestCase):
@classmethod @classmethod
def test_unique_slug_update(cls): def test_unique_slug_update(cls):
obj = cls.Model.objects.create(title={settings.LANGUAGE_CODE: 'mytitle'}) obj = cls.Model.objects.create(
assert obj.slug.get() == 'mytitle' title={settings.LANGUAGE_CODE: "mytitle"}
obj.title.set(settings.LANGUAGE_CODE, 'othertitle') )
assert obj.slug.get() == "mytitle"
obj.title.set(settings.LANGUAGE_CODE, "othertitle")
obj.save() obj.save()
assert obj.slug.get() == 'othertitle' assert obj.slug.get() == "othertitle"
@classmethod @classmethod
def test_unique_slug_unique_max_retries(cls): def test_unique_slug_unique_max_retries(cls):
"""Tests whether the unique slug implementation doesn't """Tests whether the unique slug implementation doesn't try to find a
try to find a slug forever and gives up after a while.""" slug forever and gives up after a while."""
title = 'myuniquetitle' title = "myuniquetitle"
obj = cls.Model() obj = cls.Model()
obj.title.en = title obj.title.en = title
@ -111,106 +114,112 @@ class LocalizedSlugFieldTestCase(TestCase):
"""Tests whether the populating feature works correctly.""" """Tests whether the populating feature works correctly."""
obj = cls.Model() obj = cls.Model()
obj.title.en = 'this is my title' obj.title.en = "this is my title"
obj.save() obj.save()
assert obj.slug.get('en') == slugify(obj.title) assert obj.slug.get("en") == slugify(obj.title)
@classmethod @classmethod
def test_populate_callable(cls): def test_populate_callable(cls):
"""Tests whether the populating feature works correctly """Tests whether the populating feature works correctly when you
when you specify a callable.""" specify a callable."""
def generate_slug(instance): def generate_slug(instance):
return instance.title return instance.title
get_fake_model({ get_fake_model(
'title': LocalizedField(), {
'slug': LocalizedUniqueSlugField(populate_from=generate_slug) "title": LocalizedField(),
}) "slug": LocalizedUniqueSlugField(populate_from=generate_slug),
}
)
obj = cls.Model() obj = cls.Model()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
obj.title.set(lang_code, 'title %s' % lang_name) obj.title.set(lang_code, "title %s" % lang_name)
obj.save() obj.save()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
assert obj.slug.get(lang_code) == 'title-%s' % lang_name.lower() assert obj.slug.get(lang_code) == "title-%s" % lang_name.lower()
@staticmethod @staticmethod
def test_populate_multiple_from_fields(): def test_populate_multiple_from_fields():
"""Tests whether populating the slug from multiple """Tests whether populating the slug from multiple fields works
fields works correctly.""" correctly."""
model = get_fake_model( model = get_fake_model(
{ {
'title': LocalizedField(), "title": LocalizedField(),
'name': models.CharField(max_length=255), "name": models.CharField(max_length=255),
'slug': LocalizedUniqueSlugField(populate_from=('title', 'name')) "slug": LocalizedUniqueSlugField(
populate_from=("title", "name")
),
} }
) )
obj = model() obj = model()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
obj.name = 'swen' obj.name = "swen"
obj.title.set(lang_code, 'title %s' % lang_name) obj.title.set(lang_code, "title %s" % lang_name)
obj.save() obj.save()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
assert obj.slug.get(lang_code) == 'title-%s-swen' % lang_name.lower() assert (
obj.slug.get(lang_code) == "title-%s-swen" % lang_name.lower()
)
@staticmethod @staticmethod
def test_populate_multiple_from_fields_fk(): def test_populate_multiple_from_fields_fk():
"""Tests whether populating the slug from multiple """Tests whether populating the slug from multiple fields works
fields works correctly.""" correctly."""
model_fk = get_fake_model( model_fk = get_fake_model({"name": LocalizedField()})
{
'name': LocalizedField(),
}
)
model = get_fake_model( model = get_fake_model(
{ {
'title': LocalizedField(), "title": LocalizedField(),
'other': models.ForeignKey(model_fk, on_delete=models.CASCADE), "other": models.ForeignKey(model_fk, on_delete=models.CASCADE),
'slug': LocalizedUniqueSlugField(populate_from=('title', 'other.name')) "slug": LocalizedUniqueSlugField(
populate_from=("title", "other.name")
),
} }
) )
other = model_fk.objects.create(name={settings.LANGUAGE_CODE: 'swen'}) other = model_fk.objects.create(name={settings.LANGUAGE_CODE: "swen"})
obj = model() obj = model()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
obj.other_id = other.id obj.other_id = other.id
obj.title.set(lang_code, 'title %s' % lang_name) obj.title.set(lang_code, "title %s" % lang_name)
obj.save() obj.save()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
assert obj.slug.get(lang_code) == 'title-%s-swen' % lang_name.lower() assert (
obj.slug.get(lang_code) == "title-%s-swen" % lang_name.lower()
)
@classmethod @classmethod
def test_populate_multiple_languages(cls): def test_populate_multiple_languages(cls):
"""Tests whether the populating feature correctly """Tests whether the populating feature correctly works for all
works for all languages.""" languages."""
obj = cls.Model() obj = cls.Model()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
obj.title.set(lang_code, 'title %s' % lang_name) obj.title.set(lang_code, "title %s" % lang_name)
obj.save() obj.save()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
assert obj.slug.get(lang_code) == 'title-%s' % lang_name.lower() assert obj.slug.get(lang_code) == "title-%s" % lang_name.lower()
@classmethod @classmethod
def test_unique_slug(cls): def test_unique_slug(cls):
"""Tests whether unique slugs are properly generated.""" """Tests whether unique slugs are properly generated."""
title = 'myuniquetitle' title = "myuniquetitle"
obj = cls.Model() obj = cls.Model()
obj.title.en = title obj.title.en = title
@ -221,38 +230,36 @@ class LocalizedSlugFieldTestCase(TestCase):
another_obj.title.en = title another_obj.title.en = title
another_obj.save() another_obj.save()
assert another_obj.slug.en == '%s-%d' % (title, i) assert another_obj.slug.en == "%s-%d" % (title, i)
@classmethod @classmethod
def test_unique_slug_utf(cls): def test_unique_slug_utf(cls):
"""Tests whether generating a slug works """Tests whether generating a slug works when the value consists
when the value consists completely out completely out of non-ASCII characters."""
of non-ASCII characters."""
obj = cls.Model() obj = cls.Model()
obj.title.en = 'مكاتب للايجار بشارع بورسعيد' obj.title.en = "مكاتب للايجار بشارع بورسعيد"
obj.save() obj.save()
assert obj.slug.en == 'مكاتب-للايجار-بشارع-بورسعيد' assert obj.slug.en == "مكاتب-للايجار-بشارع-بورسعيد"
@staticmethod @staticmethod
def test_deconstruct(): def test_deconstruct():
"""Tests whether the :see:deconstruct """Tests whether the :see:deconstruct function properly retains options
function properly retains options
specified in the constructor.""" specified in the constructor."""
field = LocalizedUniqueSlugField(populate_from='title') field = LocalizedUniqueSlugField(populate_from="title")
_, _, _, kwargs = field.deconstruct() _, _, _, kwargs = field.deconstruct()
assert 'populate_from' in kwargs assert "populate_from" in kwargs
assert kwargs['populate_from'] == field.populate_from assert kwargs["populate_from"] == field.populate_from
@staticmethod @staticmethod
def test_formfield(): def test_formfield():
"""Tests whether the :see:formfield method """Tests whether the :see:formfield method returns a valid form field
returns a valid form field that is hidden.""" that is hidden."""
form_field = LocalizedUniqueSlugField(populate_from='title').formfield() form_field = LocalizedUniqueSlugField(populate_from="title").formfield()
assert isinstance(form_field, forms.CharField) assert isinstance(form_field, forms.CharField)
assert isinstance(form_field.widget, forms.HiddenInput) assert isinstance(form_field.widget, forms.HiddenInput)

122
tests/test_value.py
View File

@ -1,7 +1,7 @@
from django.db.models import F
from django.conf import settings from django.conf import settings
from django.utils import translation from django.db.models import F
from django.test import TestCase, override_settings from django.test import TestCase, override_settings
from django.utils import translation
from localized_fields.value import LocalizedValue from localized_fields.value import LocalizedValue
@ -13,16 +13,14 @@ class LocalizedValueTestCase(TestCase):
@staticmethod @staticmethod
def tearDown(): def tearDown():
"""Assures that the current language """Assures that the current language is set back to the default."""
is set back to the default."""
translation.activate(settings.LANGUAGE_CODE) translation.activate(settings.LANGUAGE_CODE)
@staticmethod @staticmethod
def test_init(): def test_init():
"""Tests whether the __init__ function """Tests whether the __init__ function of the :see:LocalizedValue class
of the :see:LocalizedValue class works works as expected."""
as expected."""
keys = get_init_values() keys = get_init_values()
value = LocalizedValue(keys) value = LocalizedValue(keys)
@ -32,9 +30,8 @@ class LocalizedValueTestCase(TestCase):
@staticmethod @staticmethod
def test_init_default_values(): def test_init_default_values():
"""Tests whether the __init__ function """Tests whether the __init__ function of the :see:LocalizedValue
of the :see:LocalizedValue accepts the accepts the default value or an empty dict properly."""
default value or an empty dict properly."""
value = LocalizedValue() value = LocalizedValue()
@ -43,21 +40,20 @@ class LocalizedValueTestCase(TestCase):
@staticmethod @staticmethod
def test_init_array(): def test_init_array():
"""Tests whether the __init__ function """Tests whether the __init__ function of :see:LocalizedValue properly
of :see:LocalizedValue properly handles an handles an array.
array.
Arrays can be passed to LocalizedValue as Arrays can be passed to LocalizedValue as a result of a ArrayAgg
a result of a ArrayAgg operation.""" operation.
"""
value = LocalizedValue(['my value']) value = LocalizedValue(["my value"])
assert value.get(settings.LANGUAGE_CODE) == 'my value' assert value.get(settings.LANGUAGE_CODE) == "my value"
@staticmethod @staticmethod
def test_get_explicit(): def test_get_explicit():
"""Tests whether the the :see:LocalizedValue """Tests whether the the :see:LocalizedValue class's :see:get function
class's :see:get function works properly works properly when specifying an explicit value."""
when specifying an explicit value."""
keys = get_init_values() keys = get_init_values()
localized_value = LocalizedValue(keys) localized_value = LocalizedValue(keys)
@ -67,9 +63,8 @@ class LocalizedValueTestCase(TestCase):
@staticmethod @staticmethod
def test_get_default_language(): def test_get_default_language():
"""Tests whether the :see:LocalizedValue """Tests whether the :see:LocalizedValue class's see:get function
class's see:get function properly properly gets the value in the default language."""
gets the value in the default language."""
keys = get_init_values() keys = get_init_values()
localized_value = LocalizedValue(keys) localized_value = LocalizedValue(keys)
@ -80,8 +75,8 @@ class LocalizedValueTestCase(TestCase):
@staticmethod @staticmethod
def test_set(): def test_set():
"""Tests whether the :see:LocalizedValue """Tests whether the :see:LocalizedValue class's see:set function works
class's see:set function works properly.""" properly."""
localized_value = LocalizedValue() localized_value = LocalizedValue()
@ -92,21 +87,21 @@ class LocalizedValueTestCase(TestCase):
@staticmethod @staticmethod
def test_eq(): def test_eq():
"""Tests whether the __eq__ operator """Tests whether the __eq__ operator of :see:LocalizedValue works
of :see:LocalizedValue works properly.""" properly."""
a = LocalizedValue({'en': 'a', 'ar': 'b'}) a = LocalizedValue({"en": "a", "ar": "b"})
b = LocalizedValue({'en': 'a', 'ar': 'b'}) b = LocalizedValue({"en": "a", "ar": "b"})
assert a == b assert a == b
b.en = 'b' b.en = "b"
assert a != b assert a != b
@staticmethod @staticmethod
def test_translate(): def test_translate():
"""Tests whether the :see:LocalizedValue """Tests whether the :see:LocalizedValue class's __str__ works
class's __str__ works properly.""" properly."""
keys = get_init_values() keys = get_init_values()
localized_value = LocalizedValue(keys) localized_value = LocalizedValue(keys)
@ -117,15 +112,12 @@ class LocalizedValueTestCase(TestCase):
@staticmethod @staticmethod
def test_translate_fallback(): def test_translate_fallback():
"""Tests whether the :see:LocalizedValue """Tests whether the :see:LocalizedValue class's translate()'s fallback
class's translate()'s fallback functionality functionality works properly."""
works properly."""
test_value = 'myvalue' test_value = "myvalue"
localized_value = LocalizedValue({ localized_value = LocalizedValue({settings.LANGUAGE_CODE: test_value})
settings.LANGUAGE_CODE: test_value
})
other_language = settings.LANGUAGES[-1][0] other_language = settings.LANGUAGES[-1][0]
@ -146,50 +138,44 @@ class LocalizedValueTestCase(TestCase):
@staticmethod @staticmethod
def test_translate_none(): def test_translate_none():
"""Tests whether the :see:LocalizedValue """Tests whether the :see:LocalizedValue class's translate() method
class's translate() method properly returns properly returns None when there is no value."""
None when there is no value."""
# with no value, we always expect it to return None # with no value, we always expect it to return None
localized_value = LocalizedValue() localized_value = LocalizedValue()
assert localized_value.translate() is None assert localized_value.translate() is None
assert str(localized_value) == '' assert str(localized_value) == ""
# with no value for the default language, the default # with no value for the default language, the default
# behavior is to return None, unless a custom fallback # behavior is to return None, unless a custom fallback
# chain is configured, which there is not for this test # chain is configured, which there is not for this test
other_language = settings.LANGUAGES[-1][0] other_language = settings.LANGUAGES[-1][0]
localized_value = LocalizedValue({ localized_value = LocalizedValue({other_language: "hey"})
other_language: 'hey'
})
translation.activate(settings.LANGUAGE_CODE) translation.activate(settings.LANGUAGE_CODE)
assert localized_value.translate() is None assert localized_value.translate() is None
assert str(localized_value) == '' assert str(localized_value) == ""
@staticmethod @staticmethod
def test_translate_fallback_custom_fallback(): def test_translate_fallback_custom_fallback():
"""Tests whether the :see:LocalizedValue class's """Tests whether the :see:LocalizedValue class's translate()'s fallback
translate()'s fallback functionality properly respects functionality properly respects the LOCALIZED_FIELDS_FALLBACKS
the LOCALIZED_FIELDS_FALLBACKS setting.""" setting."""
fallbacks = { fallbacks = {"nl": ["ro"]}
'nl': ['ro']
}
localized_value = LocalizedValue({ localized_value = LocalizedValue(
settings.LANGUAGE_CODE: settings.LANGUAGE_CODE, {settings.LANGUAGE_CODE: settings.LANGUAGE_CODE, "ro": "ro"}
'ro': 'ro' )
})
with override_settings(LOCALIZED_FIELDS_FALLBACKS=fallbacks): with override_settings(LOCALIZED_FIELDS_FALLBACKS=fallbacks):
with translation.override('nl'): with translation.override("nl"):
assert localized_value.translate() == 'ro' assert localized_value.translate() == "ro"
@staticmethod @staticmethod
def test_deconstruct(): def test_deconstruct():
"""Tests whether the :see:LocalizedValue """Tests whether the :see:LocalizedValue class's :see:deconstruct
class's :see:deconstruct function works properly.""" function works properly."""
keys = get_init_values() keys = get_init_values()
value = LocalizedValue(keys) value = LocalizedValue(keys)
@ -200,16 +186,16 @@ class LocalizedValueTestCase(TestCase):
@staticmethod @staticmethod
def test_construct_string(): def test_construct_string():
"""Tests whether the :see:LocalizedValue's constructor """Tests whether the :see:LocalizedValue's constructor assumes the
assumes the primary language when passing a single string.""" primary language when passing a single string."""
value = LocalizedValue('beer') value = LocalizedValue("beer")
assert value.get(settings.LANGUAGE_CODE) == 'beer' assert value.get(settings.LANGUAGE_CODE) == "beer"
@staticmethod @staticmethod
def test_construct_expression(): def test_construct_expression():
"""Tests whether passing expressions as values """Tests whether passing expressions as values works properly and are
works properly and are not converted to string.""" not converted to string."""
value = LocalizedValue(dict(en=F('other'))) value = LocalizedValue(dict(en=F("other")))
assert isinstance(value.en, F) assert isinstance(value.en, F)

52
tests/test_widget.py
View File

@ -1,4 +1,5 @@
import re import re
from django.conf import settings from django.conf import settings
from django.test import TestCase from django.test import TestCase
@ -11,8 +12,7 @@ class LocalizedFieldWidgetTestCase(TestCase):
@staticmethod @staticmethod
def test_widget_creation(): def test_widget_creation():
"""Tests whether a widget is created for every """Tests whether a widget is created for every language correctly."""
language correctly."""
widget = LocalizedFieldWidget() widget = LocalizedFieldWidget()
assert len(widget.widgets) == len(settings.LANGUAGES) assert len(widget.widgets) == len(settings.LANGUAGES)
@ -20,9 +20,8 @@ class LocalizedFieldWidgetTestCase(TestCase):
@staticmethod @staticmethod
def test_decompress(): def test_decompress():
"""Tests whether a :see:LocalizedValue instance """Tests whether a :see:LocalizedValue instance can correctly be
can correctly be "decompressed" over the available "decompressed" over the available widgets."""
widgets."""
localized_value = LocalizedValue() localized_value = LocalizedValue()
for lang_code, lang_name in settings.LANGUAGES: for lang_code, lang_name in settings.LANGUAGES:
@ -31,13 +30,15 @@ class LocalizedFieldWidgetTestCase(TestCase):
widget = LocalizedFieldWidget() widget = LocalizedFieldWidget()
decompressed_values = widget.decompress(localized_value) decompressed_values = widget.decompress(localized_value)
for (lang_code, _), value in zip(settings.LANGUAGES, decompressed_values): for (lang_code, _), value in zip(
settings.LANGUAGES, decompressed_values
):
assert localized_value.get(lang_code) == value assert localized_value.get(lang_code) == value
@staticmethod @staticmethod
def test_decompress_none(): def test_decompress_none():
"""Tests whether the :see:LocalizedFieldWidget correctly """Tests whether the :see:LocalizedFieldWidget correctly handles
handles :see:None.""" :see:None."""
widget = LocalizedFieldWidget() widget = LocalizedFieldWidget()
decompressed_values = widget.decompress(None) decompressed_values = widget.decompress(None)
@ -47,16 +48,17 @@ class LocalizedFieldWidgetTestCase(TestCase):
@staticmethod @staticmethod
def test_get_context_required(): def test_get_context_required():
"""Tests whether the :see:get_context correctly """Tests whether the :see:get_context correctly handles 'required'
handles 'required' attribute, separately for each subwidget.""" attribute, separately for each subwidget."""
widget = LocalizedFieldWidget() widget = LocalizedFieldWidget()
widget.widgets[0].is_required = True widget.widgets[0].is_required = True
widget.widgets[1].is_required = False widget.widgets[1].is_required = False
context = widget.get_context(name='test', value=LocalizedValue(), context = widget.get_context(
attrs=dict(required=True)) name="test", value=LocalizedValue(), attrs=dict(required=True)
assert context['widget']['subwidgets'][0]['attrs']['required'] )
assert 'required' not in context['widget']['subwidgets'][1]['attrs'] assert context["widget"]["subwidgets"][0]["attrs"]["required"]
assert "required" not in context["widget"]["subwidgets"][1]["attrs"]
@staticmethod @staticmethod
def test_get_context_langs(): def test_get_context_langs():
@ -64,20 +66,20 @@ class LocalizedFieldWidgetTestCase(TestCase):
'lang_name' attribute for each subwidget.""" 'lang_name' attribute for each subwidget."""
widget = LocalizedFieldWidget() widget = LocalizedFieldWidget()
context = widget.get_context(name='test', value=LocalizedValue(), context = widget.get_context(
attrs=dict()) name="test", value=LocalizedValue(), attrs=dict()
subwidgets_context = context['widget']['subwidgets'] )
subwidgets_context = context["widget"]["subwidgets"]
for widget, context in zip(widget.widgets, subwidgets_context): for widget, context in zip(widget.widgets, subwidgets_context):
assert 'lang_code' in context assert "lang_code" in context
assert 'lang_name' in context assert "lang_name" in context
assert widget.lang_code == context['lang_code'] assert widget.lang_code == context["lang_code"]
assert widget.lang_name == context['lang_name'] assert widget.lang_name == context["lang_name"]
@staticmethod @staticmethod
def test_render(): def test_render():
"""Tests whether the :see:LocalizedFieldWidget correctly """Tests whether the :see:LocalizedFieldWidget correctly render."""
render."""
widget = LocalizedFieldWidget() widget = LocalizedFieldWidget()
output = widget.render(name='title', value=None) output = widget.render(name="title", value=None)
assert bool(re.search('<label (.|\n|\t)*>\w+<\/label>', output)) assert bool(re.search("<label (.|\n|\t)*>\w+<\/label>", output))