def test_create_field_error_validations(self): data = copy.deepcopy(self.data) fields_data = copy.deepcopy(self.fields_with_validation) fields_data[0]['validations'][0]['value'] = 'test' data['fields'] = fields_data serializer = FormidableSerializer(data=data) self.assertFalse(serializer.is_valid())
def handle(self, *args, **options): for filename in options['filename']: with open(filename) as f: data = json.load(f) # By default, the serializer is for updating serializer = FormidableSerializer(data=data) if not options['append'] and 'id' in data: try: instance = Formidable.objects.get(id=data['id']) # If the instance is found # passing it will trigger an "update" serializer = FormidableSerializer(instance, data=data) except Formidable.DoesNotExist: self.stdout.write( 'Unknown Formidable form with pk: `%s`; creating' % data['id']) if serializer.is_valid(): serializer.save() self.stdout.write( 'Successfully populate "%s (%d)"' % (serializer.instance, serializer.instance.pk)) else: self.stdout.write('Broken "%s" %s' % (filename, serializer.errors))
def test_create_form(self): serializer = FormidableSerializer(data=self.data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.label, 'test_create') self.assertEquals(instance.description, 'description create') self.assertEquals(instance.fields.count(), 0)
def test_delete_items_on_update(self): self.dropdown_fields = self.form.fields.create( slug='dropdown-input', type_id='dropdown', label=u'weapons', order=self.form.get_next_field_order()) self.dropdown_fields.accesses.create(access_id='padawan', level='REQUIRED') order = self.dropdown_fields.get_next_order() self.dropdown_fields.items.create(key=u'gun', value=u'eagle', order=order) self.dropdown_fields.items.create(key=u'sword', value=u'excalibur', order=order + 1) data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.fields_items) data['fields'][0]['items'] = [] serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid(), serializer.errors) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertEquals(form.fields.count(), 1) field = form.fields.first() self.assertEquals(field.items.count(), 0)
def test_create_ordering(self): # aggregate fields def extend(l, elt): l.extend(elt) return l fields = reduce(extend, [ self.fields_with_items, self.fields_without_items, self.format_field_helptext, self.format_field_separator, self.format_field_title ], []) data = copy.deepcopy(self.data) data['fields'] = fields serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertTrue(form.fields.filter( slug='dropdown-input', order=0 ).exists()) self.assertTrue(form.fields.filter( slug='text_input', order=1 ).exists()) self.assertTrue(form.fields.filter( slug='myhelptext', order=2 ).exists()) self.assertTrue(form.fields.filter( slug='sepa', order=3 ).exists()) self.assertTrue(form.fields.filter( slug='mytitle', order=4 ).exists())
def test_update_fields_items(self): self.dropdown_fields = self.form.fields.create( slug='dropdown-input', type_id='dropdown', label=u'weapons', order=self.form.get_next_field_order()) self.dropdown_fields.accesses.create(access_id='padawan', level='EDITABLE') order = self.dropdown_fields.get_next_order() self.dropdown_fields.items.create(key=u'gun', value=u'eagle', order=order) self.dropdown_fields.items.create(key=u'sword', value=u'excalibur', order=order + 1) data = copy.deepcopy(self.data) data['fields'] = self.fields_items serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) field = form.fields.first() self.assertEquals(self.dropdown_fields.pk, field.pk) self.assertEquals(field.label, u'edited field') self.assertEquals(field.items.count(), 2) self.assertTrue( field.items.filter(key='gun', value='desert-eagle').exists()) self.assertTrue( field.items.filter(key='sword', value=u'Andúril').exists()) qs = field.accesses.filter(access_id='padawan', level=u'REQUIRED') self.assertTrue(qs.exists())
def test_update_fields_items(self): self.dropdown_fields = self.form.fields.create( slug='dropdown-input', type_id='dropdown', label='weapons', order=self.form.get_next_field_order() ) self.dropdown_fields.accesses.create( access_id='padawan', level=constants.EDITABLE ) order = self.dropdown_fields.get_next_order() self.dropdown_fields.items.create( value='gun', label='eagle', order=order ) self.dropdown_fields.items.create( value='sword', label='excalibur', order=order + 1 ) data = copy.deepcopy(self.data) data['fields'] = self.fields_items serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) field = form.fields.first() self.assertEquals(self.dropdown_fields.pk, field.pk) self.assertEquals(field.label, 'edited field') self.assertEquals(field.items.count(), 2) self.assertTrue( field.items.filter(value='gun', label='desert-eagle').exists() ) self.assertTrue( field.items.filter(value='sword', label='Andúril').exists() ) qs = field.accesses.filter( access_id='padawan', level=constants.REQUIRED ) self.assertTrue(qs.exists())
def test_create_form(self): serializer = FormidableSerializer(data=self.data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.label, u'test_create') self.assertEquals(instance.description, u'description create') self.assertEquals(instance.fields.count(), 0)
def test_delete_items_on_update(self): self.dropdown_fields = self.form.fields.create( slug='dropdown-input', type_id='dropdown', label='weapons', order=self.form.get_next_field_order() ) self.dropdown_fields.accesses.create( access_id='padawan', level=constants.REQUIRED ) order = self.dropdown_fields.get_next_order() self.dropdown_fields.items.create( value='gun', label='eagle', order=order ) self.dropdown_fields.items.create( value='sword', label='excalibur', order=order + 1 ) data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.fields_items) data['fields'][0]['items'] = [] serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid(), serializer.errors) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertEquals(form.fields.count(), 1) field = form.fields.first() self.assertEquals(field.items.count(), 0)
def test_create_field_without_items(self): data = copy.deepcopy(self.data) fields = copy.deepcopy(self.fields_with_items) fields[0].pop('items') data['fields'] = fields serializer = FormidableSerializer(data=data) self.assertFalse(serializer.is_valid()) self.assertIn('fields', serializer.errors)
def test_create_wrong_access(self): data = copy.deepcopy(self.data) fields = copy.deepcopy(self.fields_with_items) fields[0]['accesses'][0]['access_id'] = 'wrong' data['fields'] = fields serializer = FormidableSerializer(data=data) self.assertFalse(serializer.is_valid()) self.assertIn('fields', serializer.errors)
def test_create_wrong_access(self): data = copy.deepcopy(self.data) fields = copy.deepcopy(self.fields_with_items) fields[0]['accesses'][0]['access_id'] = u'wrong' data['fields'] = fields serializer = FormidableSerializer(data=data) self.assertFalse(serializer.is_valid()) self.assertIn('fields', serializer.errors)
def test_create_form_with_presets_invalid_argument(self): data = copy.deepcopy(self.data) data['presets'] = copy.deepcopy(self.presets_with_wrong_parameters) serializer = FormidableSerializer(data=data) self.assertFalse(serializer.is_valid(), serializer.errors) self.assertIn( serializer.errors['non_field_errors'][0], 'Preset (confirmation) argument is using an undefined field (testField2)' # noqa )
def test_create_helptext(self): data = copy.deepcopy(self.data) data['fields'] = self.format_field_helptext serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEqual(instance.fields.count(), 1) qs = instance.fields.filter(type_id='help_text', help_text='Hello') self.assertTrue(qs.exists())
def test_create_sepa(self): data = copy.deepcopy(self.data) data['fields'] = self.format_field_separator serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEqual(instance.fields.count(), 1) qs = instance.fields.filter(type_id='separator', slug='sepa') self.assertTrue(qs.exists())
def test_create_title(self): data = copy.deepcopy(self.data) data['fields'] = self.format_field_title serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEqual(instance.fields.count(), 1) qs = instance.fields.filter(type_id='title', label='This is an Onboarding Form.') self.assertTrue(qs.exists())
def handle(self, *args, **options): for filename in options['filename']: with open(filename) as f: data = json.load(f) serializer = FormidableSerializer(data=data) if serializer.is_valid(): serializer.save() self.stdout.write('Successfully populate "%s"' % filename) else: self.stdout.write('Broken "%s" %s' % (filename, serializer.errors))
def test_create_fields_with_defaults(self): data = copy.deepcopy(self.data) data['fields'] = self.fields_with_defaults serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid(), serializer.errors) instance = serializer.save() self.assertEqual(instance.fields.count(), 1) field = instance.fields.first() self.assertEqual(field.defaults.count(), 1) self.assertTrue(field.defaults.filter(value='france').exists())
def test_create_order(self): data = copy.deepcopy(self.data) data['fields'] = self.fields_with_validation serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.fields.count(), 2) self.assertTrue( instance.fields.filter(order=0, slug='text_input').exists()) self.assertTrue( instance.fields.filter(order=1, slug='input-date').exists())
def test_create_title(self): data = copy.deepcopy(self.data) data['fields'] = self.format_field_title serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEqual(instance.fields.count(), 1) qs = instance.fields.filter( type_id='title', label='This is an Onboarding Form.' ) self.assertTrue(qs.exists())
def test_create_field_with_validations(self): data = copy.deepcopy(self.data) data['fields'] = self.fields_with_validation serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.fields.count(), 2) field = instance.fields.filter(type_id=u'date').first() self.assertEquals(field.validations.count(), 1) validation = field.validations.first() self.assertEquals(validation.value, 'false')
def test_create_sepa(self): data = copy.deepcopy(self.data) data['fields'] = self.format_field_separator serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEqual(instance.fields.count(), 1) qs = instance.fields.filter( type_id='separator', slug='sepa' ) self.assertTrue(qs.exists())
def test_create_field_with_validations(self): data = copy.deepcopy(self.data) data['fields'] = self.fields_with_validation serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.fields.count(), 2) field = instance.fields.filter(type_id='date').first() self.assertEquals(field.validations.count(), 1) validation = field.validations.first() self.assertEquals(validation.value, 'false')
def test_create_field_on_update(self): data = copy.deepcopy(self.data) data['fields'] = self.fields serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertEquals(form.fields.count(), 1) field = form.fields.first() self.assertEquals(field.type_id, 'text') # check accesses are fully created self.assertEquals(field.accesses.count(), 4)
def test_create_order(self): data = copy.deepcopy(self.data) data['fields'] = self.fields_with_validation serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.fields.count(), 2) self.assertTrue( instance.fields.filter(order=0, slug='text_input').exists() ) self.assertTrue( instance.fields.filter(order=1, slug='input-date').exists() )
def test_create_defaults_on_update(self): self.form.fields.create( type_id='dropdown', label='state', slug='text', order=3, ) data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.fields_with_defaults) serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid(), serializer.errors) instance = serializer.save() field = instance.fields.get(slug='state') self.assertEqual(field.defaults.count(), 1) self.assertTrue(field.defaults.filter(value='france').exists())
def test_create_radios_buttons_field(self): data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.radios_buttons_fields) serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid(), serializer.errors) instance = serializer.save() self.assertEqual(instance.fields.count(), 1) field = instance.fields.first() self.assertTrue(field.type_id, 'radios_buttons') self.assertEqual(field.items.count(), 2) self.assertTrue( field.items.filter(order=0, key='tutu', value='toto').exists()) self.assertTrue( field.items.filter(order=1, key='foo', value='bar').exists())
def test_create_form_presets(self): data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.fields_with_validation) data['presets'] = copy.deepcopy(self.valid_presets) serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid(), serializer.errors) form = serializer.save() self.assertEqual(form.presets.count(), 1) preset = form.presets.first() self.assertTrue( preset.arguments.filter(slug='left', field_id='input-date').exists()) self.assertTrue( preset.arguments.filter(slug='right', field_id='text_input').exists())
def test_delete_on_update(self): self.dropdown_fields = self.form.fields.create( slug='dropdown-input', type_id='dropdown', label='weapons', order=self.form.get_next_field_order() ) order = self.dropdown_fields.get_next_order() self.dropdown_fields.items.create(value='gun', label='eagle', order=order) self.dropdown_fields.items.create(value='sword', label='excalibur', order=order + 1) serializer = FormidableSerializer(instance=self.form, data=self.data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertEquals(form.fields.count(), 0)
def test_create_radios_buttons_field(self): data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.radios_buttons_fields) serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid(), serializer.errors) instance = serializer.save() self.assertEqual(instance.fields.count(), 1) field = instance.fields.first() self.assertTrue(field.type_id, 'radios_buttons') self.assertEqual(field.items.count(), 2) self.assertTrue( field.items.filter(order=0, value='tutu', label='toto').exists() ) self.assertTrue( field.items.filter(order=1, value='foo', label='bar').exists() )
def test_create_field(self): data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.fields_without_items) serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.label, u'test_create') self.assertEquals(instance.description, u'description create') self.assertEquals(instance.fields.count(), 1) field = instance.fields.filter(type_id=u'text').first() self.assertEquals(field.type_id, 'text') self.assertEquals(field.label, 'text label') self.assertEquals(field.slug, 'text_input') self.assertEquals(field.items.count(), 0) # just one access has been specified, check the the other are created # with default value self.assertEquals(field.accesses.count(), 4)
def test_create_field(self): data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.fields_without_items) serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.label, 'test_create') self.assertEquals(instance.description, 'description create') self.assertEquals(instance.fields.count(), 1) field = instance.fields.filter(type_id='text').first() self.assertEquals(field.type_id, 'text') self.assertEquals(field.label, 'text label') self.assertEquals(field.slug, 'text_input') self.assertEquals(field.items.count(), 0) # just one access has been specified, check the the other are created # with default value self.assertEquals(field.accesses.count(), 4)
def test_create_form_presets(self): data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.fields_with_validation) data['presets'] = copy.deepcopy(self.valid_presets) serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid(), serializer.errors) form = serializer.save() self.assertEqual(form.presets.count(), 1) preset = form.presets.first() self.assertTrue( preset.arguments.filter( slug='left', field_id='input-date').exists() ) self.assertTrue( preset.arguments.filter( slug='right', field_id='text_input').exists() )
def test_create_field_with_items(self): data = copy.deepcopy(self.data) data['fields'] = self.fields_with_items serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.label, u'test_create') self.assertEquals(instance.description, u'description create') self.assertEquals(instance.fields.count(), 1) field = instance.fields.first() self.assertEquals(field.type_id, 'dropdown') self.assertEquals(field.label, 'dropdown label') self.assertEquals(field.slug, 'dropdown-input') self.assertEquals(field.items.count(), 2) self.assertTrue(field.items.filter(key='tutu', value='toto').exists()) self.assertTrue(field.items.filter(key='tata', value='plop').exists()) self.assertEquals(field.accesses.count(), 4)
def test_update_fields(self): self.text_field = self.form.fields.create( type_id='text', label='test text', slug='text-slug', placeholder='put your name here', help_text=u'your name', order=self.form.get_next_field_order()) self.text_field.accesses.create(access_id='padawan', level='REQUIRED') data = copy.deepcopy(self.data) data['fields'] = self.fields serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) field = form.fields.first() self.assertEquals(self.text_field.pk, field.pk) self.assertEquals(field.label, u'edited field')
def test_delete_on_update(self): self.dropdown_fields = self.form.fields.create( slug='dropdown-input', type_id='dropdown', label=u'weapons', order=self.form.get_next_field_order()) order = self.dropdown_fields.get_next_order() self.dropdown_fields.items.create(key=u'gun', value=u'eagle', order=order) self.dropdown_fields.items.create(key=u'sword', value=u'excalibur', order=order + 1) serializer = FormidableSerializer(instance=self.form, data=self.data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertEquals(form.fields.count(), 0)
def test_update_fields(self): self.text_field = self.form.fields.create( type_id='text', label='test text', slug='text-slug', placeholder='put your name here', help_text='your name', order=self.form.get_next_field_order() ) self.text_field.accesses.create( access_id='padawan', level=constants.REQUIRED ) data = copy.deepcopy(self.data) data['fields'] = self.fields serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) field = form.fields.first() self.assertEquals(self.text_field.pk, field.pk) self.assertEquals(field.label, 'edited field')
def test_create_field_with_items(self): data = copy.deepcopy(self.data) data['fields'] = self.fields_with_items serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) instance = serializer.save() self.assertEquals(instance.label, 'test_create') self.assertEquals(instance.description, 'description create') self.assertEquals(instance.fields.count(), 1) field = instance.fields.first() self.assertEquals(field.type_id, 'dropdown') self.assertEquals(field.label, 'dropdown label') self.assertEquals(field.slug, 'dropdown-input') self.assertEquals(field.items.count(), 2) self.assertTrue( field.items.filter(value='tutu', label='toto').exists() ) self.assertTrue( field.items.filter(value='tata', label='plop').exists() ) self.assertEquals(field.accesses.count(), 4)
def test_create_items_on_update(self): self.dropdown_fields = self.form.fields.create( slug='dropdown-input', type_id='dropdown', label=u'weapons', order=self.form.get_next_field_order()) self.dropdown_fields.accesses.create(access_id='padawan', level='REQUIRED') data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.fields_items) serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid(), serializer.errors) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertEquals(form.fields.count(), 1) field = form.fields.first() self.assertEquals(field.items.count(), 2) self.assertTrue( field.items.filter(key=u'sword', value=u'Andúril').exists()) self.assertTrue( field.items.filter(key=u'gun', value=u'desert-eagle').exists())
def test_order_on_update(self): self.form.fields.create(type_id='text', slug='already-there', order=0) fields_to_update = self.fields + self.fields_items + [ {'type_id': 'text', 'slug': 'already-there', 'label': 'tutu', 'accesses': []}, ] data = copy.deepcopy(self.data) data['fields'] = fields_to_update serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertTrue( self.form.fields.filter(slug='text-slug', order=0).exists() ) self.assertTrue( self.form.fields.filter(slug='dropdown-input', order=1).exists() ) self.assertTrue( self.form.fields.filter(slug='already-there', order=2).exists() )
def test_order_on_update(self): self.form.fields.create(type_id='text', slug='already-there', order=0) fields_to_update = self.fields + self.fields_items + [ { 'type_id': 'text', 'slug': 'already-there', 'label': 'tutu', 'accesses': [] }, ] data = copy.deepcopy(self.data) data['fields'] = fields_to_update serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertTrue( self.form.fields.filter(slug='text-slug', order=0).exists()) self.assertTrue( self.form.fields.filter(slug='dropdown-input', order=1).exists()) self.assertTrue( self.form.fields.filter(slug='already-there', order=2).exists())
def test_presets_on_update(self): preset = self.form.presets.create(slug='comparison', message='compare') preset.arguments.create(slug='left', field_id='field1') preset.arguments.create(slug='right', value='12') preset.arguments.create(slug='operator') self.assertEqual(self.form.presets.count(), 1) data = copy.deepcopy(self.data) data['fields'] = self.fields_with_validation data['presets'] = self.valid_presets serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid(), serializer.errors) form = serializer.save() self.assertEqual(form.pk, self.form.pk) self.assertEqual(form.presets.count(), 1) preset = form.presets.first() self.assertEqual(preset.arguments.count(), 2) self.assertTrue( preset.arguments.filter(slug='left', field_id='input-date').exists()) self.assertTrue( preset.arguments.filter(slug='right', field_id='text_input').exists())
def test_create_items_on_update(self): self.dropdown_fields = self.form.fields.create( slug='dropdown-input', type_id='dropdown', label='weapons', order=self.form.get_next_field_order() ) self.dropdown_fields.accesses.create( access_id='padawan', level='REQUIRED' ) data = copy.deepcopy(self.data) data['fields'] = copy.deepcopy(self.fields_items) serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid(), serializer.errors) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertEquals(form.fields.count(), 1) field = form.fields.first() self.assertEquals(field.items.count(), 2) self.assertTrue( field.items.filter(value='sword', label='Andúril').exists() ) self.assertTrue( field.items.filter(value='gun', label='desert-eagle').exists() )
def test_presets_on_update(self): preset = self.form.presets.create(slug='comparison', message='compare') preset.arguments.create(slug='left', field_id='field1') preset.arguments.create(slug='right', value='12') preset.arguments.create(slug='operator') self.assertEqual(self.form.presets.count(), 1) data = copy.deepcopy(self.data) data['fields'] = self.fields_with_validation data['presets'] = self.valid_presets serializer = FormidableSerializer(instance=self.form, data=data) self.assertTrue(serializer.is_valid(), serializer.errors) form = serializer.save() self.assertEqual(form.pk, self.form.pk) self.assertEqual(form.presets.count(), 1) preset = form.presets.first() self.assertEqual(preset.arguments.count(), 2) self.assertTrue( preset.arguments.filter( slug='left', field_id='input-date').exists() ) self.assertTrue( preset.arguments.filter( slug='right', field_id='text_input').exists() )
def test_create_ordering(self): # aggregate fields def extend(l, elt): l.extend(elt) return l fields = reduce(extend, [ self.fields_with_items, self.fields_without_items, self.format_field_helptext, self.format_field_separator, self.format_field_title ], []) data = copy.deepcopy(self.data) data['fields'] = fields serializer = FormidableSerializer(data=data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertTrue( form.fields.filter(slug='dropdown-input', order=0).exists()) self.assertTrue( form.fields.filter(slug='text_input', order=1).exists()) self.assertTrue( form.fields.filter(slug='myhelptext', order=2).exists()) self.assertTrue(form.fields.filter(slug='sepa', order=3).exists()) self.assertTrue(form.fields.filter(slug='mytitle', order=4).exists())
def test_create_helptext_wrong(self): data = copy.deepcopy(self.data) data['fields'] = self.format_without_field_helptext serializer = FormidableSerializer(data=data) self.assertFalse(serializer.is_valid())
def test_update_simple(self): serializer = FormidableSerializer(instance=self.form, data=self.data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertEquals(form.label, 'edited form')
def test_update_simple(self): serializer = FormidableSerializer(instance=self.form, data=self.data) self.assertTrue(serializer.is_valid()) form = serializer.save() self.assertEquals(form.pk, self.form.pk) self.assertEquals(form.label, u'edited form')
def test_serializer(self): serializer = FormidableSerializer(data=self.payload) self.assertTrue(serializer.is_valid(), serializer.errors) instance = serializer.save() self.assertEqual(instance.conditions, self.payload['conditions'])
def test_allowed_types_denied_settings(self): serializer = FormidableSerializer(data=self.payload) self.assertFalse(serializer.is_valid())
def test_allowed_types_accepted_settings(self): serializer = FormidableSerializer(data=self.payload) self.assertTrue(serializer.is_valid(), serializer.errors)