django.db.models.CharField

Here are the examples of the python api django.db.models.CharField taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

242 Examples 7

3 Source : model.py
with GNU General Public License v3.0
from 007gzs

    def ex_search_fields(cls):
        ret = set()
        for field in cls._meta.fields:
            if not field.db_index and not field.unique \
                    and field.name == 'name' and isinstance(field, models.CharField):
                ret.add(field.name)
        return ret

    @classmethod

3 Source : utils.py
with GNU General Public License v3.0
from 007gzs

    def ex_search_fields(cls):
        ret = set()
        for field in cls._meta.fields:
            if field.name == 'name' and isinstance(field, models.CharField):
                ret.add(field.name)
        return ret

    @classmethod

3 Source : test_input_types.py
with MIT License
from 0soft

    def test_char(self):
        field = models.CharField()
        input_field = get_input_field(field, _registry)
        self.assertEqual(input_field._meta.name, "String")  # type:ignore

    def test_boolean(self):

3 Source : filters.py
with GNU General Public License v3.0
from abaoMAO

    def test(cls, field, request, params, model, admin_view, field_path):
        return (
            isinstance(field, models.CharField)
            and field.max_length > 20
            or isinstance(field, models.TextField)
        )


@manager.register

3 Source : utils.py
with Mozilla Public License 2.0
from Amsterdam

def map_choices(field_name: str, choices: list) -> Case:
    """
    Creates a mapping for Postgres with case and when statements

    :param field_name:
    :param choices:
    :return Case:
    """
    return Case(
        *[When(**{field_name: value, 'then': Value(str(representation))})
          for value, representation in choices],
        output_field=CharField()
    )


def reorder_csv(file_path, ordered_field_names):

3 Source : test_migration.py
with BSD 3-Clause "New" or "Revised" License
from Aristotle-Metadata-Enterprises

    def setUpBeforeMigration(self, apps):
        Book = apps.get_model("library_app", "Book")
        self.title = "Before the migration, a string's story"
        self.description = "A moving tale of data was changed when going from place to place - but staying still!"
        self.book1 = Book.objects.create(
            title=self.title, description=self.description, number_of_pages=1
        )
        self.book1.refresh_from_db()

        # Make sure that the field we are reading is a regular CharField
        self.assertEqual(type(Book._meta.get_field("title")), models.CharField)
        self.assertEqual(self.book1.title, self.title)
        self.assertEqual(self.book1.description, self.description)

    def test_title_and_description(self):

3 Source : admin.py
with GNU General Public License v3.0
from auto-mat

    def get_queryset(self, request):
        queryset = super().get_queryset(request)
        return queryset.select_related("author", "campaign",).annotate(
            dispatched_count=Count(
                Case(
                    When(subsidiarybox__dispatched=True, then=1),
                    output_field=CharField(),
                ),
            ),
        )


@admin.register(models.DeliveryBatchDeadline)

3 Source : filters.py
with GNU General Public License v3.0
from cc0411

    def test(cls, field, request, params, model, admin_view, field_path):
        return (
                isinstance(field, models.CharField)
                and field.max_length > 20
                or isinstance(field, models.TextField)
               )


@manager.register

3 Source : fields.py
with GNU Affero General Public License v3.0
from ellisist

def get_privacy_field():
    return models.CharField(
        max_length=30, choices=PRIVACY_LEVEL_CHOICES, default="instance"
    )


def privacy_level_query(user, lookup_field="privacy_level", user_field="user"):

3 Source : migrate_to_user_libraries.py
with GNU Affero General Public License v3.0
from ellisist

def set_fid(queryset, path, stdout):
    model = queryset.model._meta.label
    qs = queryset.filter(fid=None)
    base_url = "{}{}".format(settings.FUNKWHALE_URL, path)
    stdout.write(
        "* Assigning federation ids to {} entries (path: {})".format(model, base_url)
    )
    new_fid = functions.Concat(Value(base_url), F("uuid"), output_field=CharField())
    total = qs.update(fid=new_fid)

    stdout.write("  * {} entries updated".format(total))


def update_shared_inbox_url(stdout):

3 Source : migrate_to_user_libraries.py
with GNU Affero General Public License v3.0
from ellisist

def generate_actor_urls(part, stdout):
    field = "{}_url".format(part)
    stdout.write("* Update {} for local actors...".format(field))

    queryset = federation_models.Actor.objects.local().filter(**{field: None})
    base_url = "{}/federation/actors/".format(settings.FUNKWHALE_URL)

    new_field = functions.Concat(
        Value(base_url),
        F("preferred_username"),
        Value("/{}".format(part)),
        output_field=CharField(),
    )

    queryset.update(**{field: new_field})


def main(command, **kwargs):

3 Source : admin.py
with GNU General Public License v3.0
from esrg-knights

    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        if db_field.name == "content_type":
            kwargs["queryset"] = ContentType.objects \
                .annotate(model_name=Concat('app_label', Value('.'), 'model', output_field=CharField())) \
                .filter(model_name__in=settings.MARKDOWN_IMAGE_MODELS)
        return super().formfield_for_foreignkey(db_field, request, **kwargs)

admin.site.register(MarkdownImage, MarkdownImageAdmin)

3 Source : genepanelentrysnapshot.py
with Apache License 2.0
from genomicsengland

    def get_active_slim(self, pks):
        qs = super().get_queryset().filter(panel_id__in=pks)
        return qs.annotate(
            entity_type=V("gene", output_field=models.CharField()),
            entity_name=models.F("gene_core__gene_symbol"),
        )

    def get_active(self, deleted=False, gene_symbol=None, pks=None, panel_types=None):

3 Source : genepanelsnapshot.py
with Apache License 2.0
from genomicsengland

    def cached_genes(self):
        if self.is_super_panel:
            child_panels = self.child_panels.values_list("pk", flat=True)
            qs = self.genepanelentrysnapshot_set.model.objects.filter(
                panel_id__in=child_panels
            ).prefetch_related(
                "panel", "panel__level4title", "panel__panel", "tags", "evidence"
            )
        else:
            qs = self.genepanelentrysnapshot_set.all()

        return qs.annotate(
            entity_type=V("gene", output_field=models.CharField()),
            entity_name=models.F("gene_core__gene_symbol"),
        ).order_by("entity_name")

    @cached_property

3 Source : genepanelsnapshot.py
with Apache License 2.0
from genomicsengland

    def cached_strs(self):
        if self.is_super_panel:
            child_panels = self.child_panels.values_list("pk", flat=True)
            qs = self.str_set.model.objects.filter(
                panel_id__in=child_panels
            ).prefetch_related(
                "panel", "panel__level4title", "panel__panel", "tags", "evidence"
            )
        else:
            qs = self.str_set.all()

        return qs.annotate(
            entity_type=V("str", output_field=models.CharField()),
            entity_name=models.F("name"),
        ).order_by("entity_name")

    @cached_property

3 Source : genepanelsnapshot.py
with Apache License 2.0
from genomicsengland

    def cached_regions(self):
        if self.is_super_panel:
            child_panels = self.child_panels.values_list("pk", flat=True)
            qs = self.region_set.model.objects.filter(
                panel_id__in=child_panels
            ).prefetch_related(
                "panel", "panel__level4title", "panel__panel", "tags", "evidence"
            )
        else:
            qs = self.region_set.all()

        return qs.annotate(
            entity_type=V("region", output_field=models.CharField()),
            entity_name=models.F("name"),
        ).order_by("entity_name")

    @cached_property

3 Source : region.py
with Apache License 2.0
from genomicsengland

    def get_active_slim(self, pks):
        qs = super().get_queryset().filter(panel_id__in=pks)
        return qs.annotate(
            entity_type=V("region", output_field=models.CharField()),
            entity_name=models.F("name"),
        )

    def get_active(

3 Source : strs.py
with Apache License 2.0
from genomicsengland

    def get_active_slim(self, pks):
        qs = super().get_queryset().filter(panel_id__in=pks)
        return qs.annotate(
            entity_type=V("str", output_field=models.CharField()),
            entity_name=models.F("name"),
        )

    def get_active(

3 Source : tests.py
with Apache License 2.0
from gethue

    def _create_model_class(self, class_name, get_absolute_url_method=None):
        attrs = {
            'name': models.CharField(max_length=50),
            '__module__': 'absolute_url_overrides',
        }
        if get_absolute_url_method:
            attrs['get_absolute_url'] = get_absolute_url_method

        return type(class_name, (models.Model,), attrs)

3 Source : test_checks.py
with Apache License 2.0
from gethue

    def test_required_fields_is_list(self):
        """REQUIRED_FIELDS should be a list."""
        class CustomUserNonListRequiredFields(AbstractBaseUser):
            username = models.CharField(max_length=30, unique=True)
            date_of_birth = models.DateField()

            USERNAME_FIELD = 'username'
            REQUIRED_FIELDS = 'date_of_birth'

        errors = checks.run_checks(app_configs=self.apps.get_app_configs())
        self.assertEqual(errors, [
            checks.Error(
                "'REQUIRED_FIELDS' must be a list or tuple.",
                obj=CustomUserNonListRequiredFields,
                id='auth.E001',
            ),
        ])

    @override_settings(AUTH_USER_MODEL='auth_tests.CustomUserBadRequiredFields')

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_bilateral_upper(self):
        with register_lookup(models.CharField, UpperBilateralTransform):
            Author.objects.bulk_create([
                Author(name='Doe'),
                Author(name='doe'),
                Author(name='Foo'),
            ])
            self.assertQuerysetEqual(
                Author.objects.filter(name__upper='doe'),
                ["  <  Author: Doe>", " < Author: doe>"], ordered=False)
            self.assertQuerysetEqual(
                Author.objects.filter(name__upper__contains='f'),
                [" < Author: Foo>"], ordered=False)

    def test_bilateral_inner_qs(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_bilateral_inner_qs(self):
        with register_lookup(models.CharField, UpperBilateralTransform):
            with self.assertRaises(NotImplementedError):
                Author.objects.filter(name__upper__in=Author.objects.values_list('name'))

    def test_bilateral_multi_value(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_bilateral_multi_value(self):
        with register_lookup(models.CharField, UpperBilateralTransform):
            Author.objects.bulk_create([
                Author(name='Foo'),
                Author(name='Bar'),
                Author(name='Ray'),
            ])
            self.assertQuerysetEqual(
                Author.objects.filter(name__upper__in=['foo', 'bar', 'doe']).order_by('name'),
                ['Bar', 'Foo'],
                lambda a: a.name
            )

    def test_div3_bilateral_extract(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(test=Case(
                When(integer=1, then=Value('one')),
                When(integer=2, then=Value('two')),
                default=Value('other'),
                output_field=models.CharField(),
            )).order_by('pk'),
            [(1, 'one'), (2, 'two'), (3, 'other'), (2, 'two'), (3, 'other'), (3, 'other'), (4, 'other')],
            transform=attrgetter('integer', 'test')
        )

    def test_annotate_without_default(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_with_expression_as_condition(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(f_test=Case(
                When(integer2=F('integer'), then=Value('equal')),
                When(integer2=F('integer') + 1, then=Value('+1')),
                output_field=models.CharField(),
            )).order_by('pk'),
            [(1, 'equal'), (2, '+1'), (3, '+1'), (2, 'equal'), (3, '+1'), (3, 'equal'), (4, '+1')],
            transform=attrgetter('integer', 'f_test')
        )

    def test_annotate_with_join_in_value(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_with_join_in_condition(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(join_test=Case(
                When(integer2=F('o2o_rel__integer'), then=Value('equal')),
                When(integer2=F('o2o_rel__integer') + 1, then=Value('+1')),
                default=Value('other'),
                output_field=models.CharField(),
            )).order_by('pk'),
            [(1, 'equal'), (2, '+1'), (3, '+1'), (2, 'equal'), (3, '+1'), (3, 'equal'), (4, 'other')],
            transform=attrgetter('integer', 'join_test')
        )

    def test_annotate_with_join_in_predicate(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_with_join_in_predicate(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(join_test=Case(
                When(o2o_rel__integer=1, then=Value('one')),
                When(o2o_rel__integer=2, then=Value('two')),
                When(o2o_rel__integer=3, then=Value('three')),
                default=Value('other'),
                output_field=models.CharField(),
            )).order_by('pk'),
            [(1, 'one'), (2, 'two'), (3, 'three'), (2, 'two'), (3, 'three'), (3, 'three'), (4, 'one')],
            transform=attrgetter('integer', 'join_test')
        )

    def test_annotate_with_annotation_in_value(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_with_annotation_in_condition(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(
                f_plus_1=F('integer') + 1,
            ).annotate(
                f_test=Case(
                    When(integer2=F('integer'), then=Value('equal')),
                    When(integer2=F('f_plus_1'), then=Value('+1')),
                    output_field=models.CharField(),
                ),
            ).order_by('pk'),
            [(1, 'equal'), (2, '+1'), (3, '+1'), (2, 'equal'), (3, '+1'), (3, 'equal'), (4, '+1')],
            transform=attrgetter('integer', 'f_test')
        )

    def test_annotate_with_annotation_in_predicate(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_with_annotation_in_predicate(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(
                f_minus_2=F('integer') - 2,
            ).annotate(
                test=Case(
                    When(f_minus_2=-1, then=Value('negative one')),
                    When(f_minus_2=0, then=Value('zero')),
                    When(f_minus_2=1, then=Value('one')),
                    default=Value('other'),
                    output_field=models.CharField(),
                ),
            ).order_by('pk'),
            [(1, 'negative one'), (2, 'zero'), (3, 'one'), (2, 'zero'), (3, 'one'), (3, 'one'), (4, 'other')],
            transform=attrgetter('integer', 'test')
        )

    def test_annotate_with_aggregation_in_value(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_with_aggregation_in_condition(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.values(*self.non_lob_fields).annotate(
                min=Min('fk_rel__integer'),
                max=Max('fk_rel__integer'),
            ).annotate(
                test=Case(
                    When(integer2=F('min'), then=Value('min')),
                    When(integer2=F('max'), then=Value('max')),
                    output_field=models.CharField(),
                ),
            ).order_by('pk'),
            [(1, 1, 'min'), (2, 3, 'max'), (3, 4, 'max'), (2, 2, 'min'), (3, 4, 'max'), (3, 3, 'min'), (4, 5, 'min')],
            transform=itemgetter('integer', 'integer2', 'test')
        )

    def test_annotate_with_aggregation_in_predicate(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_with_aggregation_in_predicate(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.values(*self.non_lob_fields).annotate(
                max=Max('fk_rel__integer'),
            ).annotate(
                test=Case(
                    When(max=3, then=Value('max = 3')),
                    When(max=4, then=Value('max = 4')),
                    default=Value(''),
                    output_field=models.CharField(),
                ),
            ).order_by('pk'),
            [(1, 1, ''), (2, 3, 'max = 3'), (3, 4, 'max = 4'), (2, 3, 'max = 3'),
             (3, 4, 'max = 4'), (3, 4, 'max = 4'), (4, 5, '')],
            transform=itemgetter('integer', 'max', 'test')
        )

    def test_annotate_exclude(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_exclude(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(test=Case(
                When(integer=1, then=Value('one')),
                When(integer=2, then=Value('two')),
                default=Value('other'),
                output_field=models.CharField(),
            )).exclude(test='other').order_by('pk'),
            [(1, 'one'), (2, 'two'), (2, 'two')],
            transform=attrgetter('integer', 'test')
        )

    def test_annotate_values_not_in_order_by(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_values_not_in_order_by(self):
        self.assertEqual(
            list(CaseTestModel.objects.annotate(test=Case(
                When(integer=1, then=Value('one')),
                When(integer=2, then=Value('two')),
                When(integer=3, then=Value('three')),
                default=Value('other'),
                output_field=models.CharField(),
            )).order_by('test').values_list('integer', flat=True)),
            [1, 4, 3, 3, 3, 2, 2]
        )

    def test_annotate_with_empty_when(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_annotate_with_empty_when(self):
        objects = CaseTestModel.objects.annotate(
            selected=Case(
                When(pk__in=[], then=Value('selected')),
                default=Value('not selected'), output_field=models.CharField()
            )
        )
        self.assertEqual(len(objects), CaseTestModel.objects.count())
        self.assertTrue(all(obj.selected == 'not selected' for obj in objects))

    def test_combined_expression(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_case_reuse(self):
        SOME_CASE = Case(
            When(pk=0, then=Value('0')),
            default=Value('1'),
            output_field=models.CharField(),
        )
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(somecase=SOME_CASE).order_by('pk'),
            CaseTestModel.objects.annotate(somecase=SOME_CASE).order_by('pk').values_list('pk', 'somecase'),
            lambda x: (x.pk, x.somecase)
        )

    def test_aggregate(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_filter_with_expression_as_condition(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.filter(string=Case(
                When(integer2=F('integer'), then=Value('2')),
                When(integer2=F('integer') + 1, then=Value('3')),
                output_field=models.CharField(),
            )).order_by('pk'),
            [(3, 4, '3'), (2, 2, '2'), (3, 4, '3')],
            transform=attrgetter('integer', 'integer2', 'string')
        )

    def test_filter_with_join_in_value(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_update_with_join_in_predicate_raise_field_error(self):
        with self.assertRaisesMessage(FieldError, 'Joined field references are not permitted in this query'):
            CaseTestModel.objects.update(
                string=Case(
                    When(o2o_rel__integer=1, then=Value('one')),
                    When(o2o_rel__integer=2, then=Value('two')),
                    When(o2o_rel__integer=3, then=Value('three')),
                    default=Value('other'),
                    output_field=models.CharField(),
                ),
            )

    def test_update_big_integer(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_update_string(self):
        CaseTestModel.objects.filter(string__in=['1', '2']).update(
            string=Case(
                When(integer=1, then=Value('1', output_field=models.CharField())),
                When(integer=2, then=Value('2', output_field=models.CharField())),
            ),
        )
        self.assertQuerysetEqual(
            CaseTestModel.objects.filter(string__in=['1', '2']).order_by('pk'),
            [(1, '1'), (2, '2'), (2, '2')],
            transform=attrgetter('integer', 'string')
        )

    def test_update_text(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_lookup_in_condition(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(
                test=Case(
                    When(integer__lt=2, then=Value('less than 2')),
                    When(integer__gt=2, then=Value('greater than 2')),
                    default=Value('equal to 2'),
                    output_field=models.CharField(),
                ),
            ).order_by('pk'),
            [
                (1, 'less than 2'), (2, 'equal to 2'), (3, 'greater than 2'), (2, 'equal to 2'), (3, 'greater than 2'),
                (3, 'greater than 2'), (4, 'greater than 2')
            ],
            transform=attrgetter('integer', 'test')
        )

    def test_lookup_different_fields(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_lookup_different_fields(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(
                test=Case(
                    When(integer=2, integer2=3, then=Value('when')),
                    default=Value('default'),
                    output_field=models.CharField(),
                ),
            ).order_by('pk'),
            [
                (1, 1, 'default'), (2, 3, 'when'), (3, 4, 'default'), (2, 2, 'default'), (3, 4, 'default'),
                (3, 3, 'default'), (4, 5, 'default')
            ],
            transform=attrgetter('integer', 'integer2', 'test')
        )

    def test_combined_q_object(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_combined_q_object(self):
        self.assertQuerysetEqual(
            CaseTestModel.objects.annotate(
                test=Case(
                    When(Q(integer=2) | Q(integer2=3), then=Value('when')),
                    default=Value('default'),
                    output_field=models.CharField(),
                ),
            ).order_by('pk'),
            [
                (1, 1, 'default'), (2, 3, 'when'), (3, 4, 'default'), (2, 2, 'when'), (3, 4, 'default'),
                (3, 3, 'when'), (4, 5, 'default')
            ],
            transform=attrgetter('integer', 'integer2', 'test')
        )

    def test_order_by_conditional_implicit(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_simple_example(self):
        self.assertQuerysetEqual(
            Client.objects.annotate(
                discount=Case(
                    When(account_type=Client.GOLD, then=Value('5%')),
                    When(account_type=Client.PLATINUM, then=Value('10%')),
                    default=Value('0%'),
                    output_field=models.CharField(),
                ),
            ).order_by('pk'),
            [('Jane Doe', '0%'), ('James Smith', '5%'), ('Jack Black', '10%')],
            transform=attrgetter('name', 'discount')
        )

    def test_lookup_example(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_lookup_example(self):
        a_month_ago = date.today() - timedelta(days=30)
        a_year_ago = date.today() - timedelta(days=365)
        self.assertQuerysetEqual(
            Client.objects.annotate(
                discount=Case(
                    When(registered_on__lte=a_year_ago, then=Value('10%')),
                    When(registered_on__lte=a_month_ago, then=Value('5%')),
                    default=Value('0%'),
                    output_field=models.CharField(),
                ),
            ).order_by('pk'),
            [('Jane Doe', '5%'), ('James Smith', '0%'), ('Jack Black', '10%')],
            transform=attrgetter('name', 'discount')
        )

    def test_conditional_update_example(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_char_field(self):
        field = models.CharField(max_length=65)
        name, path, args, kwargs = field.deconstruct()
        self.assertEqual(path, "django.db.models.CharField")
        self.assertEqual(args, [])
        self.assertEqual(kwargs, {"max_length": 65})
        field = models.CharField(max_length=65, null=True, blank=True)
        name, path, args, kwargs = field.deconstruct()
        self.assertEqual(path, "django.db.models.CharField")
        self.assertEqual(args, [])
        self.assertEqual(kwargs, {"max_length": 65, "null": True, "blank": True})

    def test_char_field_choices(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_char_field_choices(self):
        field = models.CharField(max_length=1, choices=(("A", "One"), ("B", "Two")))
        name, path, args, kwargs = field.deconstruct()
        self.assertEqual(path, "django.db.models.CharField")
        self.assertEqual(args, [])
        self.assertEqual(kwargs, {"choices": [("A", "One"), ("B", "Two")], "max_length": 1})

    def test_csi_field(self):

3 Source : test_optimizer.py
with Apache License 2.0
from gethue

    def test_create_delete_model(self):
        """
        CreateModel and DeleteModel should collapse into nothing.
        """
        self.assertOptimizesTo(
            [
                migrations.CreateModel("Foo", [("name", models.CharField(max_length=255))]),
                migrations.DeleteModel("Foo"),
            ],
            [],
        )

    def test_create_rename_model(self):

3 Source : test_optimizer.py
with Apache License 2.0
from gethue

    def _test_create_alter_foo_delete_model(self, alter_foo):
        """
        CreateModel, AlterModelTable, AlterUniqueTogether/AlterIndexTogether/
        AlterOrderWithRespectTo, and DeleteModel should collapse into nothing.
        """
        self.assertOptimizesTo(
            [
                migrations.CreateModel("Foo", [("name", models.CharField(max_length=255))]),
                migrations.AlterModelTable("Foo", "woohoo"),
                alter_foo,
                migrations.DeleteModel("Foo"),
            ],
            [],
        )

    def test_create_alter_unique_delete_model(self):

3 Source : test_optimizer.py
with Apache License 2.0
from gethue

    def test_create_model_add_field_not_through_fk(self):
        """
        AddField should NOT optimize into CreateModel if it's an FK to a model
        that's between them.
        """
        self.assertDoesNotOptimize(
            [
                migrations.CreateModel("Foo", [("name", models.CharField(max_length=255))]),
                migrations.CreateModel("Link", [("url", models.TextField())]),
                migrations.AddField("Foo", "link", models.ForeignKey("migrations.Link", models.CASCADE)),
            ],
        )

    def test_create_model_add_field_not_through_m2m_through(self):

3 Source : test_optimizer.py
with Apache License 2.0
from gethue

    def test_create_model_add_field_not_through_m2m_through(self):
        """
        AddField should NOT optimize into CreateModel if it's an M2M using a
        through that's created between them.
        """
        # Note: The middle model is not actually a valid through model,
        # but that doesn't matter, as we never render it.
        self.assertDoesNotOptimize(
            [
                migrations.CreateModel("Foo", [("name", models.CharField(max_length=255))]),
                migrations.CreateModel("LinkThrough", []),
                migrations.AddField(
                    "Foo", "link", models.ManyToManyField("migrations.Link", through="migrations.LinkThrough")
                ),
            ],
        )

    def test_create_model_alter_field(self):

3 Source : test_optimizer.py
with Apache License 2.0
from gethue

    def test_add_field_rename_field(self):
        """
        RenameField should optimize into AddField
        """
        self.assertOptimizesTo(
            [
                migrations.AddField("Foo", "name", models.CharField(max_length=255)),
                migrations.RenameField("Foo", "name", "title"),
            ],
            [
                migrations.AddField("Foo", "title", models.CharField(max_length=255)),
            ],
        )

    def test_alter_field_rename_field(self):

See More Examples