from django import forms from django.forms.formsets import DELETION_FIELD_NAME, BaseFormSet from django.forms.models import ( BaseModelFormSet, inlineformset_factory, modelform_factory, modelformset_factory, ) from django.forms.utils import ErrorDict, ErrorList from django.test import TestCase from .models import ( Host, Manager, Network, ProfileNetwork, Restaurant, User, UserPreferences, UserProfile, UserSite, ) class InlineFormsetTests(TestCase): def test_formset_over_to_field(self): """ A formset over a ForeignKey with a to_field can be saved. """ Form = modelform_factory(User, fields="__all__") FormSet = inlineformset_factory(User, UserSite, fields="__all__") # Instantiate the Form and FormSet to prove # you can create a form with no data form = Form() form_set = FormSet(instance=User()) # Now create a new User and UserSite instance data = { "serial": "1", "username": "apollo13", "usersite_set-TOTAL_FORMS": "1", "usersite_set-INITIAL_FORMS": "0", "usersite_set-MAX_NUM_FORMS": "0", "usersite_set-0-data": "10", "usersite_set-0-user": "apollo13", } user = User() form = Form(data) if form.is_valid(): user = form.save() else: self.fail("Errors found on form:%s" % form_set) form_set = FormSet(data, instance=user) if form_set.is_valid(): form_set.save() usersite = UserSite.objects.values() self.assertEqual(usersite[0]["data"], 10) self.assertEqual(usersite[0]["user_id"], "apollo13") else: self.fail("Errors found on formset:%s" % form_set.errors) # Now update the UserSite instance data = { "usersite_set-TOTAL_FORMS": "1", "usersite_set-INITIAL_FORMS": "1", "usersite_set-MAX_NUM_FORMS": "0", "usersite_set-0-id": str(usersite[0]["id"]), "usersite_set-0-data": "11", "usersite_set-0-user": "apollo13", } form_set = FormSet(data, instance=user) if form_set.is_valid(): form_set.save() usersite = UserSite.objects.values() self.assertEqual(usersite[0]["data"], 11) self.assertEqual(usersite[0]["user_id"], "apollo13") else: self.fail("Errors found on formset:%s" % form_set.errors) # Now add a new UserSite instance data = { "usersite_set-TOTAL_FORMS": "2", "usersite_set-INITIAL_FORMS": "1", "usersite_set-MAX_NUM_FORMS": "0", "usersite_set-0-id": str(usersite[0]["id"]), "usersite_set-0-data": "11", "usersite_set-0-user": "apollo13", "usersite_set-1-data": "42", "usersite_set-1-user": "apollo13", } form_set = FormSet(data, instance=user) if form_set.is_valid(): form_set.save() usersite = UserSite.objects.values().order_by("data") self.assertEqual(usersite[0]["data"], 11) self.assertEqual(usersite[0]["user_id"], "apollo13") self.assertEqual(usersite[1]["data"], 42) self.assertEqual(usersite[1]["user_id"], "apollo13") else: self.fail("Errors found on formset:%s" % form_set.errors) def test_formset_over_inherited_model(self): """ A formset over a ForeignKey with a to_field can be saved. """ Form = modelform_factory(Restaurant, fields="__all__") FormSet = inlineformset_factory(Restaurant, Manager, fields="__all__") # Instantiate the Form and FormSet to prove # you can create a form with no data form = Form() form_set = FormSet(instance=Restaurant()) # Now create a new Restaurant and Manager instance data = { "name": "Guido's House of Pasta", "manager_set-TOTAL_FORMS": "1", "manager_set-INITIAL_FORMS": "0", "manager_set-MAX_NUM_FORMS": "0", "manager_set-0-name": "Guido Van Rossum", } restaurant = User() form = Form(data) if form.is_valid(): restaurant = form.save() else: self.fail("Errors found on form:%s" % form_set) form_set = FormSet(data, instance=restaurant) if form_set.is_valid(): form_set.save() manager = Manager.objects.values() self.assertEqual(manager[0]["name"], "Guido Van Rossum") else: self.fail("Errors found on formset:%s" % form_set.errors) # Now update the Manager instance data = { "manager_set-TOTAL_FORMS": "1", "manager_set-INITIAL_FORMS": "1", "manager_set-MAX_NUM_FORMS": "0", "manager_set-0-id": str(manager[0]["id"]), "manager_set-0-name": "Terry Gilliam", } form_set = FormSet(data, instance=restaurant) if form_set.is_valid(): form_set.save() manager = Manager.objects.values() self.assertEqual(manager[0]["name"], "Terry Gilliam") else: self.fail("Errors found on formset:%s" % form_set.errors) # Now add a new Manager instance data = { "manager_set-TOTAL_FORMS": "2", "manager_set-INITIAL_FORMS": "1", "manager_set-MAX_NUM_FORMS": "0", "manager_set-0-id": str(manager[0]["id"]), "manager_set-0-name": "Terry Gilliam", "manager_set-1-name": "John Cleese", } form_set = FormSet(data, instance=restaurant) if form_set.is_valid(): form_set.save() manager = Manager.objects.values().order_by("name") self.assertEqual(manager[0]["name"], "John Cleese") self.assertEqual(manager[1]["name"], "Terry Gilliam") else: self.fail("Errors found on formset:%s" % form_set.errors) def test_inline_model_with_to_field(self): """ #13794 --- An inline model with a to_field of a formset with instance has working relations. """ FormSet = inlineformset_factory(User, UserSite, exclude=("is_superuser",)) user = User.objects.create(username="guido", serial=1337) UserSite.objects.create(user=user, data=10) formset = FormSet(instance=user) # Testing the inline model's relation self.assertEqual(formset[0].instance.user_id, "guido") def test_inline_model_with_primary_to_field(self): """An inline model with a OneToOneField with to_field & primary key.""" FormSet = inlineformset_factory( User, UserPreferences, exclude=("is_superuser",) ) user = User.objects.create(username="guido", serial=1337) UserPreferences.objects.create(user=user, favorite_number=10) formset = FormSet(instance=user) self.assertEqual(formset[0].fields["user"].initial, "guido") def test_inline_model_with_to_field_to_rel(self): """ #13794 --- An inline model with a to_field to a related field of a formset with instance has working relations. """ FormSet = inlineformset_factory(UserProfile, ProfileNetwork, exclude=[]) user = User.objects.create(username="guido", serial=1337, pk=1) self.assertEqual(user.pk, 1) profile = UserProfile.objects.create(user=user, about="about", pk=2) self.assertEqual(profile.pk, 2) ProfileNetwork.objects.create(profile=profile, network=10, identifier=10) formset = FormSet(instance=profile) # Testing the inline model's relation self.assertEqual(formset[0].instance.profile_id, 1) def test_formset_with_none_instance(self): "A formset with instance=None can be created. Regression for #11872" Form = modelform_factory(User, fields="__all__") FormSet = inlineformset_factory(User, UserSite, fields="__all__") # Instantiate the Form and FormSet to prove # you can create a formset with an instance of None Form(instance=None) FormSet(instance=None) def test_empty_fields_on_modelformset(self): """ No fields passed to modelformset_factory() should result in no fields on returned forms except for the id (#14119). """ UserFormSet = modelformset_factory(User, fields=()) formset = UserFormSet() for form in formset.forms: self.assertIn("id", form.fields) self.assertEqual(len(form.fields), 1) def test_save_as_new_with_new_inlines(self): """ Existing and new inlines are saved with save_as_new. Regression for #14938. """ efnet = Network.objects.create(name="EFNet") host1 = Host.objects.create(hostname="irc.he.net", network=efnet) HostFormSet = inlineformset_factory(Network, Host, fields="__all__") # Add a new host, modify previous host, and save-as-new data = { "host_set-TOTAL_FORMS": "2", "host_set-INITIAL_FORMS": "1", "host_set-MAX_NUM_FORMS": "0", "host_set-0-id": str(host1.id), "host_set-0-hostname": "tranquility.hub.dal.net", "host_set-1-hostname": "matrix.de.eu.dal.net", } # To save a formset as new, it needs a new hub instance dalnet = Network.objects.create(name="DALnet") formset = HostFormSet(data, instance=dalnet, save_as_new=True) self.assertTrue(formset.is_valid()) formset.save() self.assertQuerysetEqual( dalnet.host_set.order_by("hostname"), Host.objects.filter( hostname__in=[ "matrix.de.eu.dal.net", "tranquility.hub.dal.net", ] ).order_by("hostname"), ) def test_initial_data(self): user = User.objects.create(username="bibi", serial=1) UserSite.objects.create(user=user, data=7) FormSet = inlineformset_factory(User, UserSite, extra=2, fields="__all__") formset = FormSet(instance=user, initial=[{"data": 41}, {"data": 42}]) self.assertEqual(formset.forms[0].initial["data"], 7) self.assertEqual(formset.extra_forms[0].initial["data"], 41) self.assertIn('value="42"', formset.extra_forms[1].as_p()) class FormsetTests(TestCase): def test_error_class(self): """ Test the type of Formset and Form error attributes """ Formset = modelformset_factory(User, fields="__all__") data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "0", "form-0-id": "", "form-0-username": "apollo13", "form-0-serial": "1", "form-1-id": "", "form-1-username": "apollo13", "form-1-serial": "2", } formset = Formset(data) # check if the returned error classes are correct # note: formset.errors returns a list as documented self.assertIsInstance(formset.errors, list) self.assertIsInstance(formset.non_form_errors(), ErrorList) for form in formset.forms: self.assertIsInstance(form.errors, ErrorDict) self.assertIsInstance(form.non_field_errors(), ErrorList) def test_initial_data(self): User.objects.create(username="bibi", serial=1) Formset = modelformset_factory(User, fields="__all__", extra=2) formset = Formset(initial=[{"username": "apollo11"}, {"username": "apollo12"}]) self.assertEqual(formset.forms[0].initial["username"], "bibi") self.assertEqual(formset.extra_forms[0].initial["username"], "apollo11") self.assertIn('value="apollo12"', formset.extra_forms[1].as_p()) def test_extraneous_query_is_not_run(self): Formset = modelformset_factory(Network, fields="__all__") data = { "test-TOTAL_FORMS": "1", "test-INITIAL_FORMS": "0", "test-MAX_NUM_FORMS": "", "test-0-name": "Random Place", } with self.assertNumQueries(1): formset = Formset(data, prefix="test") formset.save() class CustomWidget(forms.widgets.TextInput): pass class UserSiteForm(forms.ModelForm): class Meta: model = UserSite fields = "__all__" widgets = { "id": CustomWidget, "data": CustomWidget, } localized_fields = ("data",) class Callback: def __init__(self): self.log = [] def __call__(self, db_field, **kwargs): self.log.append((db_field, kwargs)) return db_field.formfield(**kwargs) class FormfieldCallbackTests(TestCase): """ Regression for #13095 and #17683: Using base forms with widgets defined in Meta should not raise errors and BaseModelForm should respect the specified pk widget. """ def test_inlineformset_factory_default(self): Formset = inlineformset_factory( User, UserSite, form=UserSiteForm, fields="__all__" ) form = Formset().forms[0] self.assertIsInstance(form["id"].field.widget, CustomWidget) self.assertIsInstance(form["data"].field.widget, CustomWidget) self.assertFalse(form.fields["id"].localize) self.assertTrue(form.fields["data"].localize) def test_modelformset_factory_default(self): Formset = modelformset_factory(UserSite, form=UserSiteForm) form = Formset().forms[0] self.assertIsInstance(form["id"].field.widget, CustomWidget) self.assertIsInstance(form["data"].field.widget, CustomWidget) self.assertFalse(form.fields["id"].localize) self.assertTrue(form.fields["data"].localize) def assertCallbackCalled(self, callback): id_field, user_field, data_field = UserSite._meta.fields expected_log = [ (id_field, {"widget": CustomWidget}), (user_field, {}), (data_field, {"widget": CustomWidget, "localize": True}), ] self.assertEqual(callback.log, expected_log) def test_inlineformset_custom_callback(self): callback = Callback() inlineformset_factory( User, UserSite, form=UserSiteForm, formfield_callback=callback, fields="__all__", ) self.assertCallbackCalled(callback) def test_modelformset_custom_callback(self): callback = Callback() modelformset_factory(UserSite, form=UserSiteForm, formfield_callback=callback) self.assertCallbackCalled(callback) class BaseCustomDeleteFormSet(BaseFormSet): """ A formset mix-in that lets a form decide if it's to be deleted. Works for BaseFormSets. Also works for ModelFormSets with #14099 fixed. form.should_delete() is called. The formset delete field is also suppressed. """ def add_fields(self, form, index): super().add_fields(form, index) self.can_delete = True if DELETION_FIELD_NAME in form.fields: del form.fields[DELETION_FIELD_NAME] def _should_delete_form(self, form): return hasattr(form, "should_delete") and form.should_delete() class FormfieldShouldDeleteFormTests(TestCase): """ BaseModelFormSet should use ModelFormSet method _should_delete_form. """ class BaseCustomDeleteModelFormSet(BaseModelFormSet, BaseCustomDeleteFormSet): """Model FormSet with CustomDelete MixIn""" class CustomDeleteUserForm(forms.ModelForm): """A model form with a 'should_delete' method""" class Meta: model = User fields = "__all__" def should_delete(self): """Delete form if odd serial.""" return self.instance.serial % 2 != 0 NormalFormset = modelformset_factory( User, form=CustomDeleteUserForm, can_delete=True ) DeleteFormset = modelformset_factory( User, form=CustomDeleteUserForm, formset=BaseCustomDeleteModelFormSet ) data = { "form-TOTAL_FORMS": "4", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "4", "form-0-username": "John", "form-0-serial": "1", "form-1-username": "Paul", "form-1-serial": "2", "form-2-username": "George", "form-2-serial": "3", "form-3-username": "Ringo", "form-3-serial": "5", } delete_all_ids = { "form-0-DELETE": "1", "form-1-DELETE": "1", "form-2-DELETE": "1", "form-3-DELETE": "1", } def test_init_database(self): """Add test data to database via formset""" formset = self.NormalFormset(self.data) self.assertTrue(formset.is_valid()) self.assertEqual(len(formset.save()), 4) def test_no_delete(self): """Verify base formset doesn't modify database""" # reload database self.test_init_database() # pass standard data dict & see none updated data = dict(self.data) data["form-INITIAL_FORMS"] = 4 data.update( { "form-%d-id" % i: user.pk for i, user in enumerate(User.objects.order_by("pk")) } ) formset = self.NormalFormset(data, queryset=User.objects.all()) self.assertTrue(formset.is_valid()) self.assertEqual(len(formset.save()), 0) self.assertEqual(len(User.objects.all()), 4) def test_all_delete(self): """Verify base formset honors DELETE field""" # reload database self.test_init_database() # create data dict with all fields marked for deletion data = dict(self.data) data["form-INITIAL_FORMS"] = 4 data.update( {"form-%d-id" % i: user.pk for i, user in enumerate(User.objects.all())} ) data.update(self.delete_all_ids) formset = self.NormalFormset(data, queryset=User.objects.all()) self.assertTrue(formset.is_valid()) self.assertEqual(len(formset.save()), 0) self.assertEqual(len(User.objects.all()), 0) def test_custom_delete(self): """Verify DeleteFormset ignores DELETE field and uses form method""" # reload database self.test_init_database() # Create formset with custom Delete function # create data dict with all fields marked for deletion data = dict(self.data) data["form-INITIAL_FORMS"] = 4 data.update( { "form-%d-id" % i: user.pk for i, user in enumerate(User.objects.order_by("pk")) } ) data.update(self.delete_all_ids) formset = self.DeleteFormset(data, queryset=User.objects.all()) # Three with odd serial values were deleted. self.assertTrue(formset.is_valid()) self.assertEqual(len(formset.save()), 0) self.assertEqual(User.objects.count(), 1) # No odd serial values left. odd_serials = [user.serial for user in User.objects.all() if user.serial % 2] self.assertEqual(len(odd_serials), 0) class RedeleteTests(TestCase): def test_resubmit(self): u = User.objects.create(username="foo", serial=1) us = UserSite.objects.create(user=u, data=7) formset_cls = inlineformset_factory(User, UserSite, fields="__all__") data = { "serial": "1", "username": "foo", "usersite_set-TOTAL_FORMS": "1", "usersite_set-INITIAL_FORMS": "1", "usersite_set-MAX_NUM_FORMS": "1", "usersite_set-0-id": str(us.pk), "usersite_set-0-data": "7", "usersite_set-0-user": "foo", "usersite_set-0-DELETE": "1", } formset = formset_cls(data, instance=u) self.assertTrue(formset.is_valid()) formset.save() self.assertEqual(UserSite.objects.count(), 0) formset = formset_cls(data, instance=u) # Even if the "us" object isn't in the DB any more, the form # validates. self.assertTrue(formset.is_valid()) formset.save() self.assertEqual(UserSite.objects.count(), 0) def test_delete_already_deleted(self): u = User.objects.create(username="foo", serial=1) us = UserSite.objects.create(user=u, data=7) formset_cls = inlineformset_factory(User, UserSite, fields="__all__") data = { "serial": "1", "username": "foo", "usersite_set-TOTAL_FORMS": "1", "usersite_set-INITIAL_FORMS": "1", "usersite_set-MAX_NUM_FORMS": "1", "usersite_set-0-id": str(us.pk), "usersite_set-0-data": "7", "usersite_set-0-user": "foo", "usersite_set-0-DELETE": "1", } formset = formset_cls(data, instance=u) us.delete() self.assertTrue(formset.is_valid()) formset.save() self.assertEqual(UserSite.objects.count(), 0)