def test_messages(self):
""" test if the error messages are exported
"""
form = ZMIForm('test', '<EncodingTest>')
form.manage_addField('int_field', 'int Field', 'IntegerField')
form2 = ZMIForm('test2', 'ValueTest')
request = FakeRequest()
for message_key in form.int_field.get_error_names():
request[message_key] = 'test message for error key <%s>' % message_key
form.int_field.manage_messages(REQUEST=request)
xml = formToXML(form)
XMLToForm(xml, form2)
# print xml
request.clear()
request['field_int_field'] = 'not a number'
try:
form.validate_all(request)
self.fail('form should fail in validation')
except FormValidationError, e:
self.assertEquals(1, len(e.errors))
text1 = e.errors[0].error_text
def test_messages(self):
""" test if the error messages are exported
"""
form = ZMIForm("test", "<EncodingTest>")
form.manage_addField("int_field", "int Field", "IntegerField")
form2 = ZMIForm("test2", "ValueTest")
request = FakeRequest()
for message_key in form.int_field.get_error_names():
request[message_key] = "test message for error key <%s>" % message_key
form.int_field.manage_messages(REQUEST=request)
xml = formToXML(form)
XMLToForm(xml, form2)
# print xml
request.clear()
request["field_int_field"] = "not a number"
try:
form.validate_all(request)
self.fail("form should fail in validation")
except FormValidationError, e:
self.assertEquals(1, len(e.errors))
text1 = e.errors[0].error_text
def test_emptyGroup(self):
""" test bugfix: empty groups are allowed in the XMLForm """
form = ZMIForm('test', 'GroupTest')
form.add_group('empty')
form2 = ZMIForm('test2', 'GroupTestCopy')
xml = formToXML(form)
XMLToForm(xml, form2)
# print xml
self.assertEqualForms(form, form2)
def test_serializeDateTimeValues(self):
form = ZMIForm('test', 'DateTime')
form.manage_addField('date_field', 'Date Field', 'DateTimeField')
form.date_field.values['start_datetime'] = DateTime('2004/01/01 12:01:00')
form2 = ZMIForm('test', 'DateTime2')
xml = formToXML(form)
XMLToForm(xml, form2)
self.assertEqualForms(form, form2)
def __call__(self, context, identifier, path):
with open(path, 'rb') as data:
form = ZMIForm(identifier, 'Parameters form')
try:
form.set_xml(data.read())
except:
logger.exception('''
Error while installing Formulator form id "%s" in "%s"
''' % (identifier, '/'.join(context.getPhysicalPath())))
else:
if identifier == 'parameters':
context.set_form(form)
else:
context._setObject(identifier, form)
def __init__(self, id, title, unicode_mode=0, encoding='UTF-8',
stored_encoding='UTF-8'):
"""Initialize form.
id -- id of form
title -- the title of the form
"""
ZMIForm.inheritedAttribute('__init__')(self, "", "POST", "", id,
encoding, stored_encoding,
unicode_mode)
self.id = id
self.title = title
self.row_length = 4
self.group_list = ["left", "right", "center", "bottom", "hidden"]
groups = {}
for group in self.group_list:
groups[group] = []
self.groups = groups
def manage_renameObject(self, id, new_id, REQUEST=None):
# overriden to keep the order of a field after rename
groups = deepcopy(self.groups)
ret = ZMIForm.manage_renameObject(self, id, new_id, REQUEST=REQUEST)
for group_id, field_id_list in groups.items():
if id in field_id_list:
index = field_id_list.index(id)
field_id_list.pop(index)
field_id_list.insert(index, new_id)
groups[group_id] = field_id_list
self.groups = groups
return ret
def test_emptyGroup(self):
""" test bugfix: empty groups are allowed in the XMLForm """
form = ZMIForm('test', 'GroupTest')
form.add_group('empty')
form2 = ZMIForm('test2', 'GroupTestCopy')
xml = formToXML(form)
XMLToForm(xml, form2)
# print xml
# XXX actually the empty group is not rendered anyway, but
# if we get here, we are behind the bug anyway ...
self.assertEquals(form.render(), form2.render())
self.assertEquals(form.get_groups(), form2.get_groups())
def test_deserializeFlushesOldFields(self):
# test that deserializing a form removes old values which
# have been defined on that from previously
# this may be an issue if one edits a form directly
# via the ZMI "XML" tab; removing a field in the XML did not
# remove that field from the form contents
form = ZMIForm('test', 'Source')
form2 = ZMIForm('test2', 'Target')
form.manage_addField('date_field', 'Date Field', 'DateTimeField')
form2.manage_addField('another_field', 'String Field', 'StringField')
xml = formToXML(form)
XMLToForm(xml, form2)
self.assertEqualForms(form, form2)
self.failIf( form2.has_field('another_field') )
self.failIf('another_field' in form2.objectIds() )
def manage_addCodeSource(context,
id,
title=None,
script_id=None,
fs_location=None,
REQUEST=None):
"""Add a CodeSource object
"""
cs = CodeSource(id, script_id, fs_location)
if title is not None:
title = unicode(title, cs.management_page_charset)
cs.set_title(title)
context._setObject(id, cs)
cs = context._getOb(id)
cs.set_form(ZMIForm('form', 'Parameters form', unicode_mode=1))
add_and_edit(context, id, REQUEST, screen='editCodeSource')
return ''
def question_created(question, event):
service = getUtility(IServicePolls)
editable = question.get_editable()
if service.automatically_hide_question():
# Hide poll question of tocs if setting is set by default.
binding = getUtility(IMetadataService).getMetadata(editable)
binding.setValues('silva-extra', {'hide_from_tocs': 'hide'}, reindex=1)
# Create question in storage.
editable.qid = service.create_question('', [])
# Set the code source configuration form thingy.
cs_form = ZMIForm('form', 'Properties Form')
cs_filename = os.path.join(
os.path.dirname(__file__),
'cs_configuration_form.form')
with open(cs_filename) as cs_file:
XMLToForm(cs_file.read(), cs_form)
question.parameters = cs_form
def test_fieldValueTypes(self):
""" test checking if the field values are of the proper type.
after reading from XML some field values may not have the right type,
if they have a special type (currently int and "list").
Also tests if rendering and validation are the same
between the original form and the one after one form -> xml -> form
roundtrip.
"""
form = ZMIForm('test', 'ValueTest')
form.manage_addField('int_field', 'Test Integer Field', 'IntegerField')
form.manage_addField('float_field', 'Test Float Field', 'FloatField')
form.manage_addField('date_field', 'Test Date Field', 'DateTimeField')
form.manage_addField('list_field', 'Test List Field', 'ListField')
form.manage_addField('multi_field', 'Test Checkbox Field', 'MultiCheckBoxField')
form.manage_addField('link_field', 'Test Link Field', 'LinkField')
form.manage_addField('empty_field', 'Test Empty Field', 'StringField')
int_field = getattr(form, 'int_field')
float_field = getattr(form, 'float_field')
date_field = getattr(form, 'date_field')
list_field = getattr(form, 'list_field')
multi_field = getattr(form, 'multi_field')
link_field = getattr(form, 'link_field')
empty_field = getattr(form, 'empty_field')
# XXX editing fields by messing with a fake request
# -- any better way to do this?
default_values = {'field_title': 'Test Title',
'field_display_width': '92',
'field_required':'checked',
'field_enabled':'checked',
}
try:
request = FakeRequest()
for key, sub_field in int_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update( {'field_default':'42',
'field_enabled':'checked'})
int_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in float_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update( {'field_default':'1.7',
'field_input_style':'-1234.5'})
float_field.manage_edit(REQUEST=request)
# XXX cannot test "defaults to now", as this may fail randomly
request.clear()
for key, sub_field in date_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update( {'field_input_style': 'list',
'field_input_order': 'mdy',
'field_date_only': '',
'field_css_class': 'test_css',
'field_time_separator': '$',
'subfield_field_default_year': '',
'subfield_field_default_month': '',
'subfield_field_default_day': '',
'subfield_field_default_hour': '',
'subfield_field_default_minute': '',
'subfield_field_start_datetime_year': '',
'subfield_field_start_datetime_month': '',
'subfield_field_start_datetime_day': '',
'subfield_field_start_datetime_hour': '',
'subfield_field_start_datetime_minute': '',
'subfield_field_end_datetime_year': '',
'subfield_field_end_datetime_month': '',
'subfield_field_end_datetime_day': '',
'subfield_field_end_datetime_hour': '',
'subfield_field_end_datetime_minute': '',
})
date_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in list_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update( {'field_default':'foo',
'field_size':'1',
'field_items':'Foo | foo\n Bar | bar'})
list_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in multi_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update( {'field_default':'foo',
'field_size':'3',
'field_items':'Foo | foo\n Bar | bar\nBaz | baz',
'field_orientation':'horizontal',
'field_view_separator':'<br />\n',
})
multi_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in link_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update( {'field_default':'http://www.absurd.org',
'field_required':'1',
'field_check_timeout':'5.0',
'field_link_type':'external',
})
link_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in empty_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update( {'field_default':'None',
'field_required':'',
})
empty_field.manage_edit(REQUEST=request)
except ValidationError, e:
self.fail('error when editing field %s; error message: %s' %
(e.field_id, e.error_text) )
def test_fieldValueTypes(self):
""" test checking if the field values are of the proper type.
after reading from XML some field values may not have the right type,
if they have a special type (currently int and "list").
Also tests if rendering and validation are the same
between the original form and the one after one form -> xml -> form
roundtrip.
"""
form = ZMIForm("test", "ValueTest")
form.manage_addField("int_field", "Test Integer Field", "IntegerField")
form.manage_addField("float_field", "Test Float Field", "FloatField")
form.manage_addField("date_field", "Test Date Field", "DateTimeField")
form.manage_addField("list_field", "Test List Field", "ListField")
form.manage_addField("multi_field", "Test Checkbox Field", "MultiCheckBoxField")
form.manage_addField("link_field", "Test Link Field", "LinkField")
form.manage_addField("empty_field", "Test Empty Field", "StringField")
int_field = getattr(form, "int_field")
float_field = getattr(form, "float_field")
date_field = getattr(form, "date_field")
list_field = getattr(form, "list_field")
multi_field = getattr(form, "multi_field")
link_field = getattr(form, "link_field")
empty_field = getattr(form, "empty_field")
# XXX editing fields by messing with a fake request
# -- any better way to do this?
default_values = {
"field_title": "Test Title",
"field_display_width": "92",
"field_required": "checked",
"field_enabled": "checked",
}
try:
request = FakeRequest()
for key, sub_field in int_field.form.fields.iteritems():
request["field_%s" % key] = sub_field.render_pdf()
request.update(default_values)
request.update({"field_default": "42", "field_enabled": "checked"})
int_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in float_field.form.fields.iteritems():
request["field_%s" % key] = sub_field.render_pdf()
request.update(default_values)
request.update({"field_default": "1.7", "field_input_style": "-1234.5"})
float_field.manage_edit(REQUEST=request)
# XXX cannot test "defaults to now", as this may fail randomly
request.clear()
for key, sub_field in date_field.form.fields.iteritems():
request["field_%s" % key] = sub_field.render_pdf()
request.update(default_values)
request.update(
{
"field_input_style": "list",
"field_input_order": "mdy",
"field_date_only": "",
"field_css_class": "test_css",
"field_time_separator": "$",
"subfield_field_default_year": "",
"subfield_field_default_month": "",
"subfield_field_default_day": "",
"subfield_field_default_hour": "",
"subfield_field_default_minute": "",
"subfield_field_start_datetime_year": "",
"subfield_field_start_datetime_month": "",
"subfield_field_start_datetime_day": "",
"subfield_field_start_datetime_hour": "",
"subfield_field_start_datetime_minute": "",
"subfield_field_end_datetime_year": "",
"subfield_field_end_datetime_month": "",
"subfield_field_end_datetime_day": "",
"subfield_field_end_datetime_hour": "",
"subfield_field_end_datetime_minute": "",
}
)
date_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in list_field.form.fields.iteritems():
request["field_%s" % key] = sub_field.render_pdf()
request.update(default_values)
request.update({"field_default": "foo", "field_size": "1", "field_items": "Foo | foo\n Bar | bar"})
list_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in multi_field.form.fields.iteritems():
request["field_%s" % key] = sub_field.render_pdf()
request.update(default_values)
request.update(
{
"field_default": "foo",
"field_size": "3",
"field_items": "Foo | foo\n Bar | bar\nBaz | baz",
"field_orientation": "horizontal",
"field_view_separator": "<br />\n",
}
)
multi_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in link_field.form.fields.iteritems():
request["field_%s" % key] = sub_field.render_pdf()
request.update(default_values)
request.update(
{
"field_default": "http://www.absurd.org",
"field_required": "1",
"field_check_timeout": "5.0",
"field_link_type": "external",
}
)
link_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in empty_field.form.fields.iteritems():
request["field_%s" % key] = sub_field.render_pdf()
request.update(default_values)
request.update({"field_default": "None", "field_required": ""})
empty_field.manage_edit(REQUEST=request)
except ValidationError, e:
self.fail("error when editing field %s; error message: %s" % (e.field_id, e.error_text))
def test_escaping(self):
""" test if the necessary elements are escaped in the XML.
(Actually this test is very incomplete)
"""
form = ZMIForm('test', '<EncodingTest>')
# XXX don't test escaping of name, as needs to be javascript
# valid anyway?
form.name = 'name'
form.add_group('a & b')
form.manage_addField('string_field', '<string> Field', 'StringField')
form.manage_addField('int_field', '<int> Field', 'IntegerField')
form.manage_addField('float_field', '<Float> Field', 'FloatField')
form.manage_addField('date_field', '<Date> Field', 'DateTimeField')
form.manage_addField('list_field', '<List> Field', 'ListField')
form.manage_addField('multi_field', '<Checkbox> Field', 'MultiCheckBoxField')
form2 = ZMIForm('test2', 'ValueTest')
xml = formToXML(form)
XMLToForm(xml, form2)
for field in form.get_fields():
self.assert_(form2.has_field(field.getId()))
field2 = getattr(form2, field.getId())
# XXX test if values are the same
self.assertEquals(field.values, field2.values)
# test if default renderings are the same
self.assertEquals(field.render(), field2.render())
self.assertEquals(form.title, form2.title)
self.assertEquals(form.name, form2.name)
self.assertEquals(form.action, form2.action)
self.assertEquals(form.enctype, form2.enctype)
self.assertEquals(form.method, form2.method)
# if we have forgotten something, this will usually remind us ;-)
self.assertEquals(form.render(), form2.render())
link_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in empty_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update( {'field_default':'None',
'field_required':'',
})
empty_field.manage_edit(REQUEST=request)
except ValidationError, e:
self.fail('error when editing field %s; error message: %s' %
(e.field_id, e.error_text) )
form2 = ZMIForm('test2', 'ValueTest')
xml = formToXML(form)
XMLToForm(xml, form2)
for field in form.get_fields():
self.assert_(form2.has_field(field.getId()))
field2 = getattr(form2, field.getId())
# XXX In Formulator, None and '' are treated as nearly
# being identical, and validators often turn '' to None.
# So there may be false positive, if we compare the values
# naively.
message = 'the values of %r and %r are different: %r != %r' \
% (field, field2, field.values, field2.values)
self.assertEquals(sorted(field.values.iterkeys()),
def _set_form(self):
self.parameters = ZMIForm('form', 'Properties Form')
with open(os.path.join(_home, 'photo_gallery_form.form')) as form:
XMLToForm(form.read(), self.parameters)
def test_serializeDeserializeEncodedMessages(self):
# test for serializing and deserializing XML with non-ascii text in
# the message tags
xml1 = """\
<?xml version="1.0"?>
<form>
<title></title>
<row_length>4</row_length>
<name>testform_bugs</name>
<action></action>
<method>POST</method>
<enctype></enctype>
<encoding>UTF-8</encoding>
<stored_encoding>UTF-8</stored_encoding>
<unicode_mode>false</unicode_mode>
<i18n_domain></i18n_domain>
<groups>
<group>
<title>Default</title>
<fields>
<field><id>string</id> <type>StringField</type>
<values>
<alternate_name></alternate_name>
<css_class></css_class>
<default></default>
<description>मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</description>
<display_maxwidth></display_maxwidth>
<display_width type="int">20</display_width>
<enabled type="int">1</enabled>
<external_validator></external_validator>
<extra></extra>
<hidden type="int">0</hidden>
<max_length></max_length>
<required type="int">1</required>
<title>मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</title>
<truncate type="int">0</truncate>
<unicode type="int">0</unicode>
<whitespace_preserve type="int">0</whitespace_preserve>
</values>
<tales>
</tales>
<messages>
<message name="external_validator_failed">मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</message>
<message name="required_not_found">मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</message>
<message name="too_long">मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</message>
</messages>
</field>
</fields>
</group>
</groups>
</form>
"""
# we're not expecting exceptions, and don't really care about anything
# else, so no asserts here...
form = ZMIForm('foo', 'Foo')
XMLToForm(xml1, form)
xml_roundtrip = formToXML(form)
xml1 = """\
<?xml version="1.0"?>
<form>
<title></title>
<row_length>4</row_length>
<name>testform_bugs</name>
<action></action>
<method>POST</method>
<enctype></enctype>
<encoding>UTF-8</encoding>
<stored_encoding>UTF-8</stored_encoding>
<unicode_mode>true</unicode_mode>
<i18n_domain></i18n_domain>
<groups>
<group>
<title>Default</title>
<fields>
<field><id>string</id> <type>StringField</type>
<values>
<alternate_name></alternate_name>
<css_class></css_class>
<default></default>
<description>मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</description>
<display_maxwidth></display_maxwidth>
<display_width type="int">20</display_width>
<enabled type="int">1</enabled>
<external_validator></external_validator>
<extra></extra>
<hidden type="int">0</hidden>
<max_length></max_length>
<required type="int">1</required>
<title>मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</title>
<truncate type="int">0</truncate>
<unicode type="int">0</unicode>
<whitespace_preserve type="int">0</whitespace_preserve>
</values>
<tales>
</tales>
<messages>
<message name="external_validator_failed">मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</message>
<message name="required_not_found">मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</message>
<message name="too_long">मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा</message>
</messages>
</field>
</fields>
</group>
</groups>
</form>
"""
# we're not expecting exceptions, and don't really care about anything
# else, so no asserts here...
form = ZMIForm('foo', 'Foo')
XMLToForm(xml1, form)
xml_roundtrip = formToXML(form)
def reset_parameter_form(source):
with open(os.path.join(DATA_PATH, 'csvparameters.xml')) as data:
form = ZMIForm('form', 'Parameters form', unicode_mode=1)
XMLToForm(data.read(), form)
source.set_form(form)
def test_simpleSerialize(self):
form = ZMIForm('test', 'My test')
xml = '''\
<?xml version="1.0" encoding="iso-8859-1" ?>
<form>
<title></title>
<name>tab_status_form</name>
<action></action>
<enctype></enctype>
<method></method>
<groups>
<group>
<title>Default</title>
<fields>
<field><id>message</id> <type>RawTextAreaField</type>
<values>
<alternate_name></alternate_name>
<hidden type="int">0</hidden>
<max_length></max_length>
<width type="int">65</width>
<external_validator></external_validator>
<height type="int">7</height>
<required type="int">0</required>
<css_class></css_class>
<default></default>
<title>Message</title>
<truncate type="int">0</truncate>
<description></description>
<extra>wrap="soft"</extra>
</values>
<tales>
</tales>
</field>
<field><id>publish_datetime</id> <type>DateTimeField</type>
<values>
<date_only type="int">0</date_only>
<alternate_name></alternate_name>
<input_style>list</input_style>
<hidden type="int">0</hidden>
<input_order>dmy</input_order>
<time_separator>:</time_separator>
<date_separator>/</date_separator>
<external_validator></external_validator>
<required type="int">0</required>
<default_now type="int">0</default_now>
<css_class></css_class>
<title>Publish time</title>
<description></description>
</values>
<tales>
<time_separator>python:form.time_punctuation</time_separator>
<date_separator>python:form.date_punctuation</date_separator>
</tales>
</field>
<field><id>expiration_datetime</id> <type>DateTimeField</type>
<values>
<date_only type="int">0</date_only>
<alternate_name></alternate_name>
<input_style>list</input_style>
<css_class></css_class>
<hidden type="int">0</hidden>
<input_order>dmy</input_order>
<time_separator>:</time_separator>
<date_separator>/</date_separator>
<external_validator></external_validator>
<required type="int">0</required>
<default_now type="int">0</default_now>
<title>Expiration time</title>
<description>If this document should expire, set the time.</description>
</values>
<tales>
<time_separator>python:form.time_punctuation</time_separator>
<date_separator>python:form.date_punctuation</date_separator>
</tales>
</field>
<field><id>expires_flag</id> <type>CheckBoxField</type>
<values>
<alternate_name></alternate_name>
<hidden type="int">0</hidden>
<css_class></css_class>
<default type="int">0</default>
<title>Expire flag</title>
<description>Turn on expiration time?</description>
<external_validator></external_validator>
<extra></extra>
</values>
<tales>
</tales>
</field>
</fields>
</group>
</groups>
</form>'''
XMLToForm(xml, form)
s = formToXML(form)
f = open('output1.txt', 'w')
f.write(s)
f.close()
form2 = ZMIForm('another', 'Something')
XMLToForm(xml, form2)
f = open('output2.txt', 'w')
f.write(formToXML(form2))
f.close()
def test_fieldValueTypes(self):
""" test checking if the field values are of the proper type.
after reading from XML some field values may not have the right type,
if they have a special type (currently int and "list").
Also tests if rendering and validation are the same
between the original form and the one after one form -> xml -> form
roundtrip.
"""
form = ZMIForm('test', 'ValueTest')
form.manage_addField('int_field', 'Test Integer Field', 'IntegerField')
form.manage_addField('float_field', 'Test Float Field', 'FloatField')
form.manage_addField('date_field', 'Test Date Field', 'DateTimeField')
form.manage_addField('list_field', 'Test List Field', 'ListField')
form.manage_addField('multi_field', 'Test Checkbox Field',
'MultiCheckBoxField')
form.manage_addField('link_field', 'Test Link Field', 'LinkField')
form.manage_addField('empty_field', 'Test Empty Field', 'StringField')
int_field = getattr(form, 'int_field')
float_field = getattr(form, 'float_field')
date_field = getattr(form, 'date_field')
list_field = getattr(form, 'list_field')
multi_field = getattr(form, 'multi_field')
link_field = getattr(form, 'link_field')
empty_field = getattr(form, 'empty_field')
# XXX editing fields by messing with a fake request
# -- any better way to do this?
default_values = {
'field_title': 'Test Title',
'field_display_width': '92',
'field_required': 'checked',
'field_enabled': 'checked',
}
try:
request = FakeRequest()
for key, sub_field in int_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update({'field_default': '42', 'field_enabled': 'checked'})
int_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in float_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update({
'field_default': '1.7',
'field_input_style': '-1234.5'
})
float_field.manage_edit(REQUEST=request)
# XXX cannot test "defaults to now", as this may fail randomly
request.clear()
for key, sub_field in date_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update({
'field_input_style': 'list',
'field_input_order': 'mdy',
'field_date_only': '',
'field_css_class': 'test_css',
'field_time_separator': '$',
'subfield_field_default_year': '',
'subfield_field_default_month': '',
'subfield_field_default_day': '',
'subfield_field_default_hour': '',
'subfield_field_default_minute': '',
'subfield_field_start_datetime_year': '',
'subfield_field_start_datetime_month': '',
'subfield_field_start_datetime_day': '',
'subfield_field_start_datetime_hour': '',
'subfield_field_start_datetime_minute': '',
'subfield_field_end_datetime_year': '',
'subfield_field_end_datetime_month': '',
'subfield_field_end_datetime_day': '',
'subfield_field_end_datetime_hour': '',
'subfield_field_end_datetime_minute': '',
})
date_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in list_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update({
'field_default': 'foo',
'field_size': '1',
'field_items': 'Foo | foo\n Bar | bar'
})
list_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in multi_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update({
'field_default': 'foo',
'field_size': '3',
'field_items': 'Foo | foo\n Bar | bar\nBaz | baz',
'field_orientation': 'horizontal',
'field_view_separator': '<br />\n',
})
multi_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in link_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update({
'field_default': 'http://www.absurd.org',
'field_required': '1',
'field_check_timeout': '5.0',
'field_link_type': 'external',
})
link_field.manage_edit(REQUEST=request)
request.clear()
for key, sub_field in empty_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update({
'field_default': 'None',
'field_required': '',
})
empty_field.manage_edit(REQUEST=request)
except ValidationError, e:
self.fail('error when editing field %s; error message: %s' %
(e.field_id, e.error_text))
def test_escaping(self):
""" test if the necessary elements are escaped in the XML.
(Actually this test is very incomplete)
"""
form = ZMIForm('test', '<EncodingTest>')
# XXX don't test escaping of name, as needs to be javascript
# valid anyway?
form.name = 'name'
form.add_group('a & b')
form.manage_addField('string_field', '<string> Field', 'StringField')
form.manage_addField('int_field', '<int> Field', 'IntegerField')
form.manage_addField('float_field', '<Float> Field', 'FloatField')
form.manage_addField('date_field', '<Date> Field', 'DateTimeField')
form.manage_addField('list_field', '<List> Field', 'ListField')
form.manage_addField('multi_field', '<Checkbox> Field',
'MultiCheckBoxField')
form2 = ZMIForm('test2', 'ValueTest')
xml = formToXML(form)
XMLToForm(xml, form2)
for field in form.get_fields():
self.assert_(form2.has_field(field.getId()))
field2 = getattr(form2, field.getId())
# XXX test if values are the same
self.assertEqual(field.values, field2.values)
# test if default renderings are the same
self.assertEqual(field.render(), field2.render())
self.assertEqual(form.title, form2.title)
self.assertEqual(form.name, form2.name)
self.assertEqual(form.action, form2.action)
self.assertEqual(form.enctype, form2.enctype)
self.assertEqual(form.method, form2.method)
# if we have forgotten something, this will usually remind us ;-)
self.assertEqual(form.render(), form2.render())
request.clear()
for key, sub_field in empty_field.form.fields.iteritems():
request['field_%s' % key] = sub_field.render_pdf()
request.update(default_values)
request.update({
'field_default': 'None',
'field_required': '',
})
empty_field.manage_edit(REQUEST=request)
except ValidationError, e:
self.fail('error when editing field %s; error message: %s' %
(e.field_id, e.error_text))
form2 = ZMIForm('test2', 'ValueTest')
xml = formToXML(form)
XMLToForm(xml, form2)
for field in form.get_fields():
self.assert_(form2.has_field(field.getId()))
field2 = getattr(form2, field.getId())
# XXX In Formulator, None and '' are treated as nearly
# being identical, and validators often turn '' to None.
# So there may be false positive, if we compare the values
# naively.
message = 'the values of %r and %r are different: %r != %r' \
% (field, field2, field.values, field2.values)
self.assertEqual(sorted(field.values.iterkeys()),
def test_escaping(self):
""" test if the necessary elements are escaped in the XML.
(Actually this test is very incomplete)
"""
form = ZMIForm('test', '<EncodingTest>')
# XXX don't test escaping of name, as needs to be javascript
# valid anyway?
form.name = 'name'
form.add_group('a & b')
form.manage_addField('string_field', '<string> Field', 'StringField')
form.manage_addField('int_field', '<int> Field', 'IntegerField')
form.manage_addField('float_field', '<Float> Field', 'FloatField')
form.manage_addField('date_field', '<Date> Field', 'DateTimeField')
form.manage_addField('list_field', '<List> Field', 'ListField')
form.manage_addField('multi_field', '<Checkbox> Field', 'MultiCheckBoxField')
form2 = ZMIForm('test2', 'ValueTest')
xml = formToXML(form)
XMLToForm(xml, form2)
self.assertEqualForms(form, form2)
def test_escaping(self):
""" test if the necessary elements are escaped in the XML.
(Actually this test is very incomplete)
"""
form = ZMIForm('test', '<EncodingTest>')
# XXX don't test escaping of name, as needs to be javascript
# valid anyway?
form.name = 'name'
form.add_group('a & b')
form.manage_addField('string_field', '<string> Field', 'StringField')
form.manage_addField('int_field', '<int> Field', 'IntegerField')
form.manage_addField('float_field', '<Float> Field', 'FloatField')
form.manage_addField('date_field', '<Date> Field', 'DateTimeField')
form.manage_addField('list_field', '<List> Field', 'ListField')
form.manage_addField('multi_field', '<Checkbox> Field',
'MultiCheckBoxField')
form2 = ZMIForm('test2', 'ValueTest')
xml = formToXML(form)
XMLToForm(xml, form2)
self.assertEqualForms(form, form2)
