Bump version to 5.1

Remove extra dot in example integration code

.circleci/config.yml

@@ -0,0 +1,92 @@
+version: 2
+jobs:
+    test-python35:
+        docker:
+            - image: python:3.5-alpine
+            - image: postgres:11.0
+              environment:
+                  POSTGRES_DB: 'localizedfields'
+                  POSTGRES_USER: 'localizedfields'
+                  POSTGRES_PASSWORD: 'localizedfields'
+        steps:
+            - checkout
+            - run:
+                name: Install packages
+                command: apk add postgresql-libs gcc musl-dev postgresql-dev git
+            - run:
+                name: Install Python packages
+                command: pip install -r requirements/test.txt
+            - run:
+                name: Run tests
+                command: tox -e 'py35-dj{111,20,21}'
+                environment:
+                    DATABASE_URL: 'postgres://localizedfields:localizedfields@localhost:5432/localizedfields'
+
+    test-python36:
+        docker:
+            - image: python:3.6-alpine
+            - image: postgres:11.0
+              environment:
+                  POSTGRES_DB: 'localizedfields'
+                  POSTGRES_USER: 'localizedfields'
+                  POSTGRES_PASSWORD: 'localizedfields'
+        steps:
+            - checkout
+            - run:
+                name: Install packages
+                command: apk add postgresql-libs gcc musl-dev postgresql-dev git
+            - run:
+                name: Install Python packages
+                command: pip install -r requirements/test.txt
+            - run:
+                name: Run tests
+                command: tox -e 'py36-dj{111,20,21}'
+                environment:
+                    DATABASE_URL: 'postgres://localizedfields:localizedfields@localhost:5432/localizedfields'
+
+    test-python37:
+        docker:
+            - image: python:3.7-alpine
+            - image: postgres:11.0
+              environment:
+                  POSTGRES_DB: 'localizedfields'
+                  POSTGRES_USER: 'localizedfields'
+                  POSTGRES_PASSWORD: 'localizedfields'
+        steps:
+            - checkout
+            - run:
+                name: Install packages
+                command: apk add postgresql-libs gcc musl-dev postgresql-dev git
+            - run:
+                name: Install Python packages
+                command: pip install -r requirements/test.txt
+            - run:
+                name: Run tests
+                command: tox -e 'py37-dj{111,20,21}'
+                environment:
+                    DATABASE_URL: 'postgres://localizedfields:localizedfields@localhost:5432/localizedfields'
+
+    lint:
+        docker:
+            - image: python:3.5-alpine
+        steps:
+            - checkout
+            - run:
+                name: Install packages
+                command: apk add postgresql-libs gcc musl-dev postgresql-dev git
+            - run:
+                name: Install Python packages
+                command: pip install -r requirements/test.txt
+            - run:
+                name: Lint code
+                command: python setup.py lint
+
+
+workflows:
+    version: 2
+    build:
+        jobs:
+            - test-python35
+            - test-python36
+            - test-python37
+            - lint

.coveragerc

@@ -1,5 +1,3 @@
 [run]
 include = localized_fields/*
 omit = *migrations*, *tests*
-plugins =
-    django_coverage_plugin

.gitignore

@@ -1,5 +1,6 @@
 # Ignore virtual environments
 env/
+.env/
 
 # Ignore Python byte code cache
 *.pyc

.scrutinizer.yml

@@ -1,34 +0,0 @@
-checks:
-    python:
-        code_rating: true
-        duplicate_code: true
-tools:
-    pylint:
-        python_version: '3'
-        config_file: .pylintrc
-filter:
-    excluded_paths:
-        - '*/tests/*'
-        - '*/migrations/*'
-build:
-    environment:
-        python: '3.5.0'
-        variables:
-            DJANGO_SETTINGS_MODULES: settings
-            DATABASE_URL: postgres://scrutinizer:scrutinizer@localhost:5434/localized_fields
-        postgresql: true
-
-    dependencies:
-        override:
-            - 'pip install -r requirements/test.txt'
-    tests:
-        override:
-            -
-                command: pep8 ./localized_fields/
-            -
-                command: flake8 ./localized_fields/
-            -
-                command: tox
-                coverage:
-                    file: '.coverage'
-                    format: 'py-cc'

.travis.yml

@@ -1,18 +0,0 @@
-env:
- - DJANGO_SETTINGS_MODULE=settings
-sudo: true
-before_install:
-  - sudo apt-get update -qq
-  - sudo apt-get install -qq build-essential gettext python-dev zlib1g-dev libpq-dev xvfb
-  - sudo apt-get install -qq libtiff4-dev libjpeg8-dev libfreetype6-dev liblcms1-dev libwebp-dev
-  - sudo apt-get install -qq graphviz-dev python-setuptools python3-dev python-virtualenv python-pip
-  - sudo apt-get install -qq firefox automake libtool libreadline6 libreadline6-dev libreadline-dev
-  - sudo apt-get install -qq libsqlite3-dev libxml2 libxml2-dev libssl-dev libbz2-dev wget curl llvm
-language: python
-python:
-- "3.5"
-services:
- - postgresql
-install: "pip install -r requirements/test.txt"
-script:
-    - coverage run manage.py test

README.rst

@@ -1,11 +1,8 @@
 django-localized-fields
 =======================
 
-.. image:: https://scrutinizer-ci.com/g/SectorLabs/django-localized-fields/badges/quality-score.png
+.. image:: https://circleci.com/gh/SectorLabs/django-localized-fields.svg?style=svg
-    :target: https://scrutinizer-ci.com/g/SectorLabs/django-localized-fields/
+    :target: https://circleci.com/gh/SectorLabs/django-localized-fields
-
-.. image:: https://scrutinizer-ci.com/g/SectorLabs/django-localized-fields/badges/coverage.png
-    :target: https://scrutinizer-ci.com/g/SectorLabs/django-localized-fields/
 
 .. image:: https://img.shields.io/github/license/SectorLabs/django-localized-fields.svg
     :target: https://github.com/SectorLabs/django-localized-fields/blob/master/LICENSE.md
@@ -36,7 +33,7 @@ Installation
      .. code-block:: bash
 
         INSTALLED_APPS = [
-            ....
+            ...
 
             'django.contrib.postgres',
             'localized_fields.apps.LocalizedFieldsConfig'
@@ -282,7 +279,7 @@ Besides ``LocalizedField``, there's also:
 
     Allows storing integers in multiple languages. This works exactly like ``LocalizedField`` except that
     all values must be integers. Do note that values are stored as strings in your database because
-    the backing field type is ``hstore``, which only allows storing integers. The ``LocalizedIntegerField``
+    the backing field type is ``hstore``, which only allows storing strings. The ``LocalizedIntegerField``
     takes care of ensuring that all values are integers and converts the stored strings back to integers
     when retrieving them from the database. Do not expect to be able to do queries such as:
 
@@ -348,6 +345,7 @@ Experimental feature
 ^^^^^^^^^^^^^^^^^^^^
 Enables the following experimental features:
     * ``LocalizedField`` will return ``None`` instead of an empty ``LocalizedValue`` if there is no database value.
+    * ``LocalizedField`` lookups will lookup by currently active language instead of HStoreField
 
 .. code-block:: python
 
@@ -371,6 +369,10 @@ To enable widgets in the admin, you need to inherit from ``LocalizedFieldsAdminM
     admin.site.register(MyLocalizedModel, MyLocalizedModelAdmin)
 
 
+.. image:: ./images/admin-widget.png
+    :alt: The appearance of admin widget
+
+
 Frequently asked questions (FAQ)
 --------------------------------
 

localized_fields/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'localized_fields.apps.LocalizedFieldsConfig'

localized_fields/admin.py

@@ -1,5 +1,3 @@
-from django.contrib.admin import ModelAdmin
-
 from . import widgets
 from .fields import LocalizedField, LocalizedCharField, LocalizedTextField, \
     LocalizedFileField
@@ -13,7 +11,7 @@ FORMFIELD_FOR_LOCALIZED_FIELDS_DEFAULTS = {
 }
 
 
-class LocalizedFieldsAdminMixin(ModelAdmin):
+class LocalizedFieldsAdminMixin:
     """Mixin for making the fancy widgets work in Django Admin."""
 
     class Media:
@@ -24,6 +22,7 @@ class LocalizedFieldsAdminMixin(ModelAdmin):
         }
 
         js = (
+            'admin/js/jquery.init.js',
             'localized_fields/localized-fields-admin.js',
         )
 

localized_fields/apps.py

@@ -1,5 +1,21 @@
+import inspect
+
 from django.apps import AppConfig
+from django.conf import settings
+
+from . import lookups
+from .fields import LocalizedField
+from .lookups import LocalizedLookupMixin
 
 
 class LocalizedFieldsConfig(AppConfig):
     name = 'localized_fields'
+
+    def ready(self):
+        if getattr(settings, 'LOCALIZED_FIELDS_EXPERIMENTAL', False):
+            for _, clazz in inspect.getmembers(lookups):
+                if not inspect.isclass(clazz) or clazz is LocalizedLookupMixin:
+                    continue
+
+                if issubclass(clazz, LocalizedLookupMixin):
+                    LocalizedField.register_lookup(clazz)

localized_fields/descriptor.py

@@ -41,7 +41,7 @@ class LocalizedValueDescriptor:
 
         if self.field.name in instance.__dict__:
             value = instance.__dict__[self.field.name]
-        elif instance.pk is not None:
+        elif not instance._state.adding:
             instance.refresh_from_db(fields=[self.field.name])
             value = getattr(instance, self.field.name)
         else:

localized_fields/fields/field.py

@@ -165,7 +165,7 @@ class LocalizedField(HStoreField):
         can store in the database.
 
         For example, when all the language fields are
-        left empty, and the field is allows to be null,
+        left empty, and the field is allowed to be null,
         we will store None instead of empty keys.
 
         Arguments:

localized_fields/fields/integer_field.py

@@ -5,6 +5,7 @@ from django.db.utils import IntegrityError
 
 from .field import LocalizedField
 from ..value import LocalizedValue, LocalizedIntegerValue
+from ..forms import LocalizedIntegerFieldForm
 
 
 class LocalizedIntegerField(LocalizedField):
@@ -63,6 +64,15 @@ class LocalizedIntegerField(LocalizedField):
 
         return prepped_value
 
+    def formfield(self, **kwargs):
+        """Gets the form field associated with this field."""
+        defaults = {
+            'form_class': LocalizedIntegerFieldForm
+        }
+
+        defaults.update(kwargs)
+        return super().formfield(**defaults)
+
     @staticmethod
     def _convert_localized_value(value: LocalizedValue) -> LocalizedIntegerValue:
         """Converts from :see:LocalizedValue to :see:LocalizedIntegerValue."""

localized_fields/forms.py

@@ -6,9 +6,9 @@ from django.core.exceptions import ValidationError
 from django.forms.widgets import FILE_INPUT_CONTRADICTION
 
 from .value import LocalizedValue, LocalizedStringValue, \
-    LocalizedFileValue
+    LocalizedFileValue, LocalizedIntegerValue
 from .widgets import LocalizedFieldWidget, LocalizedCharFieldWidget, \
-    LocalizedFileWidget
+    LocalizedFileWidget, AdminLocalizedIntegerFieldWidget
 
 
 class LocalizedFieldForm(forms.MultiValueField):
@@ -79,6 +79,14 @@ class LocalizedTextFieldForm(LocalizedFieldForm):
     value_class = LocalizedStringValue
 
 
+class LocalizedIntegerFieldForm(LocalizedFieldForm):
+    """Form for a localized integer field, allows editing
+    the field in multiple languages."""
+
+    widget = AdminLocalizedIntegerFieldWidget
+    value_class = LocalizedIntegerValue
+
+
 class LocalizedFileFieldForm(LocalizedFieldForm, forms.FileField):
     """Form for a localized file field, allows editing
     the field in multiple languages."""

localized_fields/lookups.py

@@ -0,0 +1,80 @@
+from django.conf import settings
+from django.contrib.postgres.fields.hstore import KeyTransform
+from django.contrib.postgres.lookups import (SearchLookup, TrigramSimilar,
+                                             Unaccent)
+from django.db.models.expressions import Col
+from django.db.models.lookups import (Contains, EndsWith, Exact, IContains,
+                                      IEndsWith, IExact, In, IRegex, IsNull,
+                                      IStartsWith, Regex, StartsWith)
+from django.utils import translation
+
+
+class LocalizedLookupMixin():
+    def process_lhs(self, qn, connection):
+        if isinstance(self.lhs, Col):
+            language = translation.get_language() or settings.LANGUAGE_CODE
+            self.lhs = KeyTransform(language, self.lhs)
+        return super().process_lhs(qn, connection)
+
+    def get_prep_lookup(self):
+        return str(self.rhs)
+
+
+class LocalizedSearchLookup(LocalizedLookupMixin, SearchLookup):
+    pass
+
+
+class LocalizedUnaccent(LocalizedLookupMixin, Unaccent):
+    pass
+
+
+class LocalizedTrigramSimilair(LocalizedLookupMixin, TrigramSimilar):
+    pass
+
+
+class LocalizedExact(LocalizedLookupMixin, Exact):
+    pass
+
+
+class LocalizedIExact(LocalizedLookupMixin, IExact):
+    pass
+
+
+class LocalizedIn(LocalizedLookupMixin, In):
+    pass
+
+
+class LocalizedContains(LocalizedLookupMixin, Contains):
+    pass
+
+
+class LocalizedIContains(LocalizedLookupMixin, IContains):
+    pass
+
+
+class LocalizedStartsWith(LocalizedLookupMixin, StartsWith):
+    pass
+
+
+class LocalizedIStartsWith(LocalizedLookupMixin, IStartsWith):
+    pass
+
+
+class LocalizedEndsWith(LocalizedLookupMixin, EndsWith):
+    pass
+
+
+class LocalizedIEndsWith(LocalizedLookupMixin, IEndsWith):
+    pass
+
+
+class LocalizedIsNullWith(LocalizedLookupMixin, IsNull):
+    pass
+
+
+class LocalizedRegexWith(LocalizedLookupMixin, Regex):
+    pass
+
+
+class LocalizedIRegexWith(LocalizedLookupMixin, IRegex):
+    pass

localized_fields/migrations/0001_initial.py

@@ -0,0 +1,14 @@
+# Generated by Django 2.1 on 2018-08-27 08:05
+
+from django.contrib.postgres.operations import HStoreExtension
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+    ]
+
+    operations = [
+        HStoreExtension(),
+    ]

localized_fields/templates/localized_fields/multiwidget.html

@@ -1,4 +1,16 @@
-{% for widget in widget.subwidgets %}
+{% with widget_id=widget.attrs.id %}
-<label for="{{ widget.attrs.id }}">{{ widget.lang_name }}</label>
+<div class="localized-fields-widget" role="tabs" data-synctabs="translation">
-{% include widget.template_name %}
+    <ul class="localized-fields-widget tabs">
-{% endfor %}
+    {% for widget in widget.subwidgets %}
+        <li class="localized-fields-widget tab">
+            <label for="{{ widget_id }}_{{ widget.lang_code }}">{{ widget.lang_name|capfirst }}</label>
+        </li>
+    {% endfor %}
+    </ul>
+    {% for widget in widget.subwidgets %}
+        <div role="tabpanel" id="{{ widget_id }}_{{ widget.lang_code }}">
+            {% include widget.template_name %}
+        </div>
+    {% endfor %}
+</div>
+{% endwith %}

localized_fields/value.py

@@ -228,3 +228,9 @@ class LocalizedIntegerValue(LocalizedValue):
             return self.default_value
 
         return int(value)
+
+    def __str__(self) -> str:
+        """Returns string representation of value"""
+
+        value = self.translate()
+        return str(value) if value is not None else ''

localized_fields/widgets.py

@@ -1,3 +1,5 @@
+import copy
+
 from typing import List
 
 from django.conf import settings
@@ -16,7 +18,7 @@ class LocalizedFieldWidget(forms.MultiWidget):
         """Initializes a new instance of :see:LocalizedFieldWidget."""
 
         initial_widgets = [
-            self.widget
+            copy.copy(self.widget)
             for _ in settings.LANGUAGES
         ]
 
@@ -118,3 +120,7 @@ class AdminLocalizedCharFieldWidget(AdminLocalizedFieldWidget):
 
 class AdminLocalizedFileFieldWidget(AdminLocalizedFieldWidget):
     widget = widgets.AdminFileWidget
+
+
+class AdminLocalizedIntegerFieldWidget(AdminLocalizedFieldWidget):
+    widget = widgets.AdminIntegerFieldWidget

requirements/test.txt

@@ -2,15 +2,9 @@
 
 django-autoslug==1.9.3
 django-bleach==0.3.0
-django-coverage-plugin==1.3.1
 psycopg2==2.7.3.2
-pylint==1.8.1
-pylint-common==0.2.5
-pylint-django==0.8.0
-pylint-plugin-utils==0.2.6
 coverage==4.4.2
-django-coverage-plugin==1.3.1
+flake8==3.6.0
-flake8==3.5.0
 pep8==1.7.1
 dj-database-url==0.4.2
 tox==2.9.1

settings.py

@@ -21,6 +21,9 @@ LANGUAGES = (
 )
 
 INSTALLED_APPS = (
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.admin',
     'localized_fields',
     'tests',
 )

setup.cfg

@@ -1,5 +1,6 @@
 [flake8]
 max-line-length = 120
+ignore = E252, W605
 exclude = env,.tox,.git,config/settings,*/migrations/*,*/static/CACHE/*,docs,node_modules
 
 [pep8]

setup.py

@@ -1,13 +1,39 @@
 import os
+import distutils.cmd
+import subprocess
 
 from setuptools import find_packages, setup
 
+
+class BaseCommand(distutils.cmd.Command):
+    user_options = []
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+
+def create_command(text, commands):
+    """Creates a custom setup.py command."""
+
+    class CustomCommand(BaseCommand):
+        description = text
+
+        def run(self):
+            for cmd in commands:
+                subprocess.check_call(cmd)
+
+    return CustomCommand
+
+
 with open(os.path.join(os.path.dirname(__file__), 'README.rst'), encoding='utf-8') as readme:
     README = readme.read()
 
 setup(
     name='django-localized-fields',
-    version='5.0a1',
+    version='5.1',
     packages=find_packages(exclude=['tests']),
     include_package_data=True,
     license='MIT License',
@@ -18,7 +44,7 @@ setup(
     author_email='open-source@sectorlabs.ro',
     keywords=['django', 'localized', 'language', 'models', 'fields'],
     install_requires=[
-        'django-postgres-extra>=1.21a',
+        'django-postgres-extra>=1.22',
         'Django>=1.11',
         'deprecation==2.0.3'
     ],
@@ -32,5 +58,11 @@ setup(
         'Programming Language :: Python :: 3.5',
         'Topic :: Internet :: WWW/HTTP',
         'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
-    ]
+    ],
+    cmdclass={
+        'lint': create_command(
+            'Lints the code',
+            [['flake8', 'setup.py', 'localized_fields', 'tests']],
+        ),
+    },
 )

tests/test_admin.py

@@ -0,0 +1,87 @@
+from django.apps import apps
+from django.contrib import admin
+from django.contrib.admin.checks import check_admin_app
+from django.db import models
+from django.test import TestCase
+
+from localized_fields.fields import LocalizedField
+from localized_fields.admin import LocalizedFieldsAdminMixin
+
+from tests.fake_model import get_fake_model
+
+
+class LocalizedFieldsAdminMixinTestCase(TestCase):
+    """Tests the :see:LocalizedFieldsAdminMixin class."""
+
+    TestModel = None
+    TestRelModel = None
+
+    @classmethod
+    def setUpClass(cls):
+        """Creates the test model in the database."""
+
+        super(LocalizedFieldsAdminMixinTestCase, cls).setUpClass()
+
+        cls.TestRelModel = get_fake_model(
+            {
+                'description': LocalizedField()
+            }
+        )
+        cls.TestModel = get_fake_model(
+            {
+                'title': LocalizedField(),
+                'rel': models.ForeignKey(cls.TestRelModel,
+                                         on_delete=models.CASCADE)
+            }
+        )
+
+    def tearDown(self):
+        if admin.site.is_registered(self.TestModel):
+            admin.site.unregister(self.TestModel)
+        if admin.site.is_registered(self.TestRelModel):
+            admin.site.unregister(self.TestRelModel)
+
+    @classmethod
+    def test_model_admin(cls):
+        """Tests whether :see:LocalizedFieldsAdminMixin
+        mixin are works with admin.ModelAdmin"""
+
+        @admin.register(cls.TestModel)
+        class TestModelAdmin(LocalizedFieldsAdminMixin, admin.ModelAdmin):
+            pass
+
+        assert len(check_admin_app(apps.get_app_configs())) == 0
+
+    @classmethod
+    def test_stackedmodel_admin(cls):
+        """Tests whether :see:LocalizedFieldsAdminMixin mixin are works
+        with admin.StackedInline"""
+
+        class TestModelStackedInline(LocalizedFieldsAdminMixin,
+                                     admin.StackedInline):
+            model = cls.TestModel
+
+        @admin.register(cls.TestRelModel)
+        class TestRelModelAdmin(admin.ModelAdmin):
+            inlines = [
+                TestModelStackedInline,
+            ]
+
+        assert len(check_admin_app(apps.get_app_configs())) == 0
+
+    @classmethod
+    def test_tabularmodel_admin(cls):
+        """Tests whether :see:LocalizedFieldsAdminMixin mixin are works
+        with admin.TabularInline"""
+
+        class TestModelTabularInline(LocalizedFieldsAdminMixin,
+                                     admin.TabularInline):
+            model = cls.TestModel
+
+        @admin.register(cls.TestRelModel)
+        class TestRelModelAdmin(admin.ModelAdmin):
+            inlines = [
+                TestModelTabularInline,
+            ]
+
+        assert len(check_admin_app(apps.get_app_configs())) == 0

tests/test_field.py

@@ -1,6 +1,7 @@
 import json
 
 from django.conf import settings
+from django.db import models
 from django.db.utils import IntegrityError
 from django.test import TestCase
 
@@ -33,7 +34,6 @@ class LocalizedFieldTestCase(TestCase):
         field = LocalizedField(required=False)
         assert field.required == []
 
-
     @staticmethod
     def test_from_db_value():
         """Tests whether the :see:from_db_value function
@@ -205,6 +205,16 @@ class LocalizedFieldTestCase(TestCase):
         for field in field.formfield().fields:
             assert field.required
 
+    def test_descriptor_user_defined_primary_key(self):
+        """Tests that descriptor works even when primary key is user defined."""
+        model = get_fake_model(dict(
+            slug=models.SlugField(primary_key=True),
+            title=LocalizedField()
+        ))
+
+        obj = model.objects.create(slug='test', title='test')
+        assert obj.title == 'test'
+
     def test_required_all(self):
         """Tests whether passing required=True properly validates
         that all languages are filled in."""

tests/test_form.py

@@ -40,7 +40,6 @@ class LocalizedFieldFormTestCase(TestCase):
         for field in form.fields:
             assert not field.required
 
-
     @staticmethod
     def test_compress():
         """Tests whether the :see:compress function

tests/test_integer_field.py

@@ -148,7 +148,7 @@ class LocalizedIntegerFieldTestCase(TestCase):
 
         with connection.cursor() as cursor:
             table_name = self.TestModel._meta.db_table
-            cursor.execute("update %s set score = 'en=>haha'" % table_name);
+            cursor.execute("update %s set score = 'en=>haha'" % table_name)
 
         obj.refresh_from_db()
         assert obj.score.get(settings.LANGUAGE_CODE) is None

tests/test_lookups.py

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

tests/test_query_set.py

@@ -1,6 +1,4 @@
-from django.conf import settings
 from django.test import TestCase
-from django.utils import translation
 
 from localized_fields.fields import LocalizedField
 

tests/test_value.py

@@ -152,7 +152,7 @@ class LocalizedValueTestCase(TestCase):
 
         # with no value, we always expect it to return None
         localized_value = LocalizedValue()
-        assert localized_value.translate() == None
+        assert localized_value.translate() is None
         assert str(localized_value) == ''
 
         # with no value for the default language, the default
@@ -164,7 +164,7 @@ class LocalizedValueTestCase(TestCase):
         })
 
         translation.activate(settings.LANGUAGE_CODE)
-        assert localized_value.translate() == None
+        assert localized_value.translate() is None
         assert str(localized_value) == ''
 
     @staticmethod

tests/test_widget.py

@@ -16,6 +16,7 @@ class LocalizedFieldWidgetTestCase(TestCase):
 
         widget = LocalizedFieldWidget()
         assert len(widget.widgets) == len(settings.LANGUAGES)
+        assert len(set(widget.widgets)) == len(widget.widgets)
 
     @staticmethod
     def test_decompress():

tox.ini

@@ -1,10 +1,12 @@
 [tox]
-envlist = py35-dj{111,20}
+envlist = py35-dj{111,20,21,22}, py36-dj{111,20,21,22}, py37-dj{111,20,21,22}
 
 [testenv]
 deps =
     dj111: Django>=1.11,<1.12
     dj20: Django>=2.0,<2.1
+    dj21: Django>=2.1,<2.2
+    dj22: Django>=2.2,<2.3
     -rrequirements/test.txt
 setenv =
     DJANGO_SETTINGS_MODULE=settings