def test_apply_form_data(self): """Make sure that form data changes our model inst. data.""" fake_mapper = Mapper(FakeForm) fake_model = FakeModel() fake_model.item_name = '' fake_mapped_field = 'Something fake' fake_mapped_title = 'A Terrible Beginning' fake_unmapped_field = 'Will never see the light of day.' fake_form_data = { # Parent form 'name': 'Something new!', # Sub form with mapping 'test_mapping': { 'fake_field': fake_mapped_field, 'fake_title': fake_mapped_title, }, # Sub form without mapping (doesn't get applied) 'test_no_mapping': { 'fake_field': fake_unmapped_field, }, } instances = fake_mapper.apply_form_data(fake_form_data, fake_model) # We should have only modified the model which we passed in. self.assertEqual(len(instances), 1) # Test that these reference the same object self.assertEqual(instances[0], fake_model) # Parent form field's mapping updates the model: self.assertEqual(fake_model.item_name, fake_form_data['name']) # Sub form's mapping updates the model: self.assertEqual(fake_model.fake_field, fake_mapped_field) self.assertEqual(fake_model.fake_title, fake_mapped_title)
def test_get_form_data(self): """Get model data for form fields using our mapping.""" expected_output = { 'name': 'Database', 'test_no_mapping-initial': {}, 'test_mapping-initial': { 'fake_field': 'Something unexpected', 'fake_title': None, }, } fake_mapper = Mapper(FakeForm) fake_model = FakeModel() fake_model.item_name = 'Database' fake_model.fake_field = 'Something unexpected' fake_initial_form_data = fake_mapper.get_form_data(fake_model) # Our form field name (as we expect it) equals our model attribute. self.assertEqual(fake_initial_form_data, expected_output)
def test_multiple_sub_forms_one_model(self): """Ensure two sub forms modifying the same 'model' don't drop data.""" fake_form_value = 'This is some new data' class FakeFormWithSubForms(forms.Form): something = forms.CharField(required=False) model_to_form = (('something_else', 'something'),) form_to_model = (('something', 'something_else'),) # The same form validation mapped onto two separate # subforms. subform_config = ( ('subform1', SubFormWithMapping), ('subform2', OtherSubFormWithMapping), ) @ClassProperty def subforms(cls): return dict(cls.subform_config) fake_mapper = Mapper(FakeFormWithSubForms) fake_model = FakeModel() fake_field = 'Whaaaat' fake_title = 'Crrrrrrazy' fake_data = 'Yellow' form_data = { 'something': fake_form_value, 'subform2': {'fake_data': fake_data}, 'subform1': {'fake_field': fake_field, 'fake_title': fake_title}, } fake_instances = fake_mapper.apply_form_data(form_data, fake_model) # Make sure we're still working with the same model instance. self.assertEqual(fake_instances[0], fake_model) # Saved from subform 2 self.assertEqual(fake_model.fake_field, fake_field) # Saved from subform 1 self.assertEqual(fake_model.fake_data, fake_data) self.assertEqual(fake_model.fake_title, fake_title)
def test_apply_form_data_as_callable(self): """Make sure form values sent to callable update model.""" fake_form_value = 'This is some new data' def set_model_value(model_inst, value): """Pretend we're looking up "form" data from another model.""" model_inst.database = value class FakeFormWithCallable(forms.Form): something = forms.CharField(required=False) model_to_form = ((set_model_value, 'something'),) form_to_model = (('something', set_model_value),) fake_mapper = Mapper(FakeFormWithCallable) fake_model = FakeModel() fake_model.database = '' form_data = {'something': fake_form_value} fake_instances = fake_mapper.apply_form_data(form_data, fake_model) self.assertEqual(len(fake_instances), 1) fake_instance = fake_instances[0] self.assertEqual(fake_instance.database, fake_form_value)
def test_get_form_data_as_callable(self): """Use callable instead of static definition of form field.""" fake_model_value = 'Fun Test Data' def get_model_attr(model_inst): """Pretend we're looking up model data from another model.""" return fake_model_value class FakeFormWithCallable(forms.Form): something = forms.CharField(required=False) model_to_form = ((get_model_attr, 'something'),) form_to_model = (('something', get_model_attr),) fake_mapper = Mapper(FakeFormWithCallable) fake_model = FakeModel() fake_model.database = fake_model_value fake_form_data = fake_mapper.get_form_data(fake_model) self.assertEqual( fake_form_data['something'], fake_model_value )
def test_instance_for_behavior(self): """Ensure transitioning between models from form -> subform works. Note: we also test what happens when two subforms specify the same model (they should create two separate instances of the model). This behavior is probably rarely desired, but is how the system works as constructed. """ class OtherModel(object): """Model to be transitioned to from FakeModel.""" pass def return_other_model(parent_model_inst): try: result = parent_model_inst.other_model except AttributeError: result = OtherModel() return result class FakeFormWithSubForms(forms.Form): something = forms.CharField(required=False) model_to_form = (('something_else', 'something'),) form_to_model = (('something', 'something_else'),) # The same form validation mapped onto two separate # subforms. subform_config = ( ('subform1', SubFormWithMapping), ('subform2', SubFormWithMapping), ) # model to test that we don't stomp on our changes. @staticmethod def instance_for_subform1(parent_model_inst): return return_other_model(parent_model_inst) @staticmethod def instance_for_subform2(parent_model_inst): return return_other_model(parent_model_inst) @ClassProperty def subforms(cls): return dict(cls.subform_config) fake_mapper = Mapper(FakeFormWithSubForms) fake_model = FakeModel() fake_field = 'What is the meaning of this!?' fake_title = 'Canterbury Tales' form_data = { 'subform2': {'fake_title': fake_title}, 'subform1': {'fake_field': fake_field}, } # This call should result in other_model being created and set as an # attr on our fake_model fake_instances = fake_mapper.apply_form_data(form_data, fake_model) # There'll be one for each form in this case. self.assertEqual(len(fake_instances), 3) fake_sub1 = fake_instances[1] fake_sub2 = fake_instances[2] # As nice as it would be to have these data merged into one # instance, it's not easily doable, so we save into separate # instances and leave implementation to the caller. self.assertEqual(fake_sub1.fake_field, fake_field) self.assertEqual(fake_sub2.fake_title, fake_title)