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_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_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_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 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 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_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_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_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_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_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_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_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_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 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_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_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_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_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_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_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 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_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_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_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_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_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_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_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_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 setUp(self):
self.form = Formidable.objects.create(
label=u'testform',
description=u'test form',
)
self.text_field = self.form.fields.create(
type_id='text',
label='test text',
slug='test_text',
placeholder='put your name here',
help_text=u'your name',
order=self.form.get_next_field_order())
self.text_field2 = self.form.fields.create(
type_id='text',
label='test text 2',
slug='test_text_2',
placeholder='put your name here',
help_text=u'your name',
order=self.form.get_next_field_order())
self.text_field.accesses.create(level=u'REQUIRED',
access_id=u'padawan')
self.text_field2.accesses.create(level=u'EDITABLE',
access_id=u'jedi',
display='TABLE')
self.text_field.validations.create(type=u'MINLENGTH', value=u'5')
self.serializer = FormidableSerializer(instance=self.form)
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_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_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 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_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=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_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_separator_field(self):
self.form.fields.all().delete()
self.sepa = self.form.fields.create(
type_id='separator',
slug='sepa',
order=self.form.get_next_field_order())
serializer = FormidableSerializer(instance=self.form)
data = serializer.data['fields'][0]
self.assertEqual(data['type_id'], 'separator')
self.assertNotIn('label', data)
self.assertNotIn('help_text', data)
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_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_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_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_title_field(self):
self.form.fields.all().delete()
self.title = self.form.fields.create(
type_id='title',
slug='my title',
label=u'This is on onboarding form.',
order=self.form.get_next_field_order())
serializer = FormidableSerializer(instance=self.form)
data = serializer.data['fields'][0]
for field in set(RENDER_BASE_FIELDS) - set(['help_text']):
self.assertIn(field, data)
self.assertEqual(data['label'], 'This is on onboarding form.')
self.assertNotIn('help_text', data)
def test_helptext_field(self):
self.form.fields.all().delete()
self.help_text = self.form.fields.create(
type_id='help_text',
slug='your help text',
help_text=u'Please enter your information here',
order=self.form.get_next_field_order())
serializer = FormidableSerializer(instance=self.form)
data = serializer.data['fields'][0]
for field in list(set(RENDER_BASE_FIELDS) - set(['label'])):
self.assertIn(field, data)
self.assertEqual(data['help_text'],
'Please enter your information here')
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_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_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_dropdown_field(self):
self.form.fields.all().delete()
self.dropdown = self.form.fields.create(
type_id='dropdown',
label=u'choose your weapon',
order=self.form.get_next_field_order())
order = self.dropdown.get_next_order()
self.dropdown.items.create(key='tutu', value='toto', order=order)
self.dropdown.items.create(key=u'plop',
value=u'Intérnätiônal',
order=order + 1)
serializer = FormidableSerializer(instance=self.form)
data = serializer.data['fields'][0]
for field in RENDER_BASE_FIELDS:
self.assertIn(field, data)
self.assertIn('multiple', data)
self.assertEquals(data['multiple'], False)
self.assertIn('items', data)
self.assertEquals(len(data['items']), 2)
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')
