LocalizedFieldTestCase

Complexity

Total Complexity

58

Size/Duplication

Total Lines	204
Duplicated Lines	27.94 %

Importance

Changes	9
Bugs	0	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	test_from_db_value_none_return_none()	0	9	3
A	test_from_db_value()	0	10	3
A	test_to_python_non_json()	0	7	2
A	test_get_prep_value_none()	0	7	2
A	test_to_python()	0	10	3
A	test_get_prep_value()	0	13	4
A	test_from_db_value_none()	0	9	3
A	test_formfield()	0	8	2
A	test_to_python_none()	0	11	4
B	test_to_python_str()	0	13	5
A	test_get_prep_value_no_localized_value()	0	8	2
A	test_to_python_non_dict()	0	11	4
B	test_get_prep_value_clean()	0	13	5
D	test_required_all()	28	28	8
D	test_required_some()	29	29	8

import json

from django.conf import settings

The import django.conf could not be resolved.

from django.db.utils import IntegrityError

The import django.db.utils could not be resolved.

from django.test import TestCase

The import django.test could not be resolved.

from localized_fields.fields import LocalizedField
from localized_fields.forms import LocalizedFieldForm
from localized_fields.value import LocalizedValue

from .data import get_init_values
from .fake_model import get_fake_model


class LocalizedFieldTestCase(TestCase):

This class has no __init__ method.

    """Tests the :see:LocalizedField class."""

    @staticmethod
    def test_from_db_value():
        """Tests whether the :see:from_db_value function
        produces the expected :see:LocalizedValue."""

        input_data = get_init_values()
        localized_value = LocalizedField().from_db_value(input_data)

        for lang_code, _ in settings.LANGUAGES:
            assert getattr(localized_value, lang_code) == input_data[lang_code]

    @staticmethod
    def test_from_db_value_none():
        """Tests whether the :see:from_db_value function
        correctly handles None values."""

        localized_value = LocalizedField().from_db_value(None)

        for lang_code, _ in settings.LANGUAGES:
            assert localized_value.get(lang_code) is None

    def test_from_db_value_none_return_none(self):
        """Tests whether the :see:from_db_value function
        correctly handles None values when LOCALIZED_FIELDS_EXPERIMENTAL
        is set to True."""

        with self.settings(LOCALIZED_FIELDS_EXPERIMENTAL=True):

The Instance of LocalizedFieldTestCase does not seem to have a member named settings.

            localized_value = LocalizedField.from_db_value(None)

        assert localized_value is None

    @staticmethod
    def test_to_python():
        """Tests whether the :see:to_python function
        produces the expected :see:LocalizedValue."""

        input_data = get_init_values()
        localized_value = LocalizedField().to_python(input_data)

        for language, value in input_data.items():
            assert localized_value.get(language) == value

    @staticmethod
    def test_to_python_non_json():
        """Tests whether the :see:to_python function
        properly handles a string that is not JSON."""

        localized_value = LocalizedField().to_python('my value')
        assert localized_value.get() == 'my value'

    @staticmethod
    def test_to_python_none():
        """Tests whether the :see:to_python function
        produces the expected :see:LocalizedValue
        instance when it is passes None."""

        localized_value = LocalizedField().to_python(None)
        assert localized_value

        for lang_code, _ in settings.LANGUAGES:
            assert localized_value.get(lang_code) is None

    @staticmethod
    def test_to_python_non_dict():
        """Tests whether the :see:to_python function produces
        the expected :see:LocalizedValue when it is
        passed a non-dictionary value."""

        localized_value = LocalizedField().to_python(list())
        assert localized_value

        for lang_code, _ in settings.LANGUAGES:
            assert localized_value.get(lang_code) is None

    @staticmethod
    def test_to_python_str():
        """Tests whether the :see:to_python function produces
        the expected :see:LocalizedValue when it is
        passed serialized string value."""

        serialized_str = json.dumps(get_init_values())
        localized_value = LocalizedField().to_python(serialized_str)
        assert isinstance(localized_value, LocalizedValue)

        for language, value in get_init_values().items():
            assert localized_value.get(language) == value
            assert getattr(localized_value, language) == value

    @staticmethod
    def test_get_prep_value():
        """"Tests whether the :see:get_prep_value function
        produces the expected dictionary."""

        input_data = get_init_values()
        localized_value = LocalizedValue(input_data)

        output_data = LocalizedField().get_prep_value(localized_value)

        for language, value in input_data.items():
            assert language in output_data
            assert output_data.get(language) == value

    @staticmethod
    def test_get_prep_value_none():
        """Tests whether the :see:get_prep_value function
        produces the expected output when it is passed None."""

        output_data = LocalizedField().get_prep_value(None)
        assert not output_data

    @staticmethod
    def test_get_prep_value_no_localized_value():
        """Tests whether the :see:get_prep_value function
        produces the expected output when it is passed a
        non-LocalizedValue value."""

        output_data = LocalizedField().get_prep_value(['huh'])
        assert not output_data

    def test_get_prep_value_clean(self):
        """Tests whether the :see:get_prep_value produces
        None as the output when it is passed an empty, but
        valid LocalizedValue value but, only when null=True."""

        localized_value = LocalizedValue()

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            LocalizedField(null=False).get_prep_value(localized_value)

        assert not LocalizedField(null=True).get_prep_value(localized_value)
        assert not LocalizedField().clean(None)
        assert not LocalizedField().clean(['huh'])

    @staticmethod
    def test_formfield():
        """Tests whether the :see:formfield function
        correctly returns a valid form."""

        assert isinstance(
            LocalizedField().formfield(),
            LocalizedFieldForm
        )

    def test_required_all(self):

This code seems to be duplicated in your project.

        """Tests whether passing required=True properly validates
        that all languages are filled in."""

        model = get_fake_model(dict(
            title=LocalizedField(required=True)
        ))

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=dict(ro='romanian', nl='dutch'))

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=dict(nl='dutch'))

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=dict(random='random'))

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=dict())

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=None)

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title='')

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title='         ')

    def test_required_some(self):

This code seems to be duplicated in your project.

        """Tests whether passing an array to required,
        properly validates whether the specified languages
        are marked as required."""

        model = get_fake_model(dict(
            title=LocalizedField(required=['nl', 'ro'])
        ))

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=dict(ro='romanian', nl='dutch'))

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=dict(nl='dutch'))

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=dict(random='random'))

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=dict())

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title=None)

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title='')

        with self.assertRaises(IntegrityError):

The Instance of LocalizedFieldTestCase does not seem to have a member named assertRaises.

            model.objects.create(title='         ')