def test_toElementFields(self):
"""
Fields are rendered as child elements, in order.
"""
fields = [data_form.Field('fixed', value='Section 1'),
data_form.Field('text-single',
var='botname',
label='The name of your bot'),
data_form.Field('text-multi',
var='description',
label='Helpful description of your bot'),
data_form.Field('boolean',
var='public',
label='Public bot?',
required=True)
]
form = data_form.Form('form', fields=fields)
element = form.toElement()
elements = list(element.elements())
self.assertEqual(4, len(elements))
for field in elements:
self.assertEqual('field', field.name)
self.assertEqual(NS_X_DATA, field.uri)
# Check order
self.assertEqual('fixed', elements[0]['type'])
self.assertEqual('botname', elements[1]['var'])
self.assertEqual('description', elements[2]['var'])
self.assertEqual('public', elements[3]['var'])
def test_itervalues(self):
"""
Iterating over the values of a form yields all field values.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot'),
data_form.Field('boolean', var='public', value=True)]
form = data_form.Form('submit', fields=fields)
self.assertEqual(set(['The Jabber Bot', True]),
set(form.itervalues()))
def test_addFieldSameName(self):
"""
A named field cannot occur twice.
"""
form = data_form.Form('result')
field1 = data_form.Field(var='test', value='value')
field2 = data_form.Field(var='test', value='value2')
form.addField(field1)
self.assertRaises(data_form.Error, form.addField, field2)
def test_values(self):
"""
Getting the values of a form yields a list of field values.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot'),
data_form.Field('boolean', var='public', value=True)]
form = data_form.Form('submit', fields=fields)
values = form.values()
self.assertIsInstance(values, list)
self.assertEqual(set(['The Jabber Bot', True]), set(values))
def test_addFieldTwice(self):
"""
Fields occur in fieldList in the order they were added.
"""
form = data_form.Form('result')
field1 = data_form.Field('fixed', value='Section 1')
field2 = data_form.Field('fixed', value='Section 2')
form.addField(field1)
form.addField(field2)
self.assertEqual([field1, field2], form.fieldList)
def test_addFieldTwiceNamed(self):
"""
A second named field should occur in fields.
"""
form = data_form.Form('result')
field1 = data_form.Field(var='test')
field2 = data_form.Field(var='test2')
form.addField(field2)
form.addField(field1)
self.assertEqual({'test': field1, 'test2': field2}, form.fields)
def test_iterkeys(self):
"""
Iterating over the keys of a form yields all field names.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot'),
data_form.Field('boolean', var='public', value=True),
data_form.Field('list-multi', var='features',
values=['news', 'search'])]
form = data_form.Form('submit', fields=fields)
self.assertEqual(set(['botname', 'public', 'features']),
set(form.iterkeys()))
def test_getitem(self):
"""
Using Form as a mapping will yield the value of fields keyed by name.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot'),
data_form.Field('boolean', var='public', value=True),
data_form.Field('list-multi', var='features',
values=['news', 'search'])]
form = data_form.Form('submit', fields=fields)
self.assertEqual('The Jabber Bot', form['botname'])
self.assertTrue(form['public'])
self.assertEqual(['news', 'search'], form['features'])
def test_items(self):
"""
Iterating over the values of a form yields a list of all item tuples.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot'),
data_form.Field('boolean', var='public', value=True)]
form = data_form.Form('submit', fields=fields)
items = form.items()
self.assertIsInstance(items, list)
self.assertEqual(set([('botname', 'The Jabber Bot'),
('public', True)]),
set(items))
def _addOptionsFromDict(self, request, conf):
form = data_form.Form(formType="submit",
formNamespace=NS_PUBSUB_NODE_CONFIG)
for k,v in conf.iteritems():
if getattr(v, '__iter__', False) and not isinstance(v, basestring):
form.addField(data_form.Field(fieldType='text-multi',
var=k, values=[str(x) for x in v]))
else:
form.addField(data_form.Field(var=k, value=str(v)))
request.options = form
def test_addUser(self):
d = self.protocol.addUser(u'*****@*****.**', u'secret')
iq = self.stub.output[-1]
self.assertEqual(u'example.com', iq.getAttribute(u'to'))
self.assertEqual(u'set', iq.getAttribute(u'type'))
self.assertEqual(protocols.NS_COMMANDS, iq.command.uri)
self.failIf(iq.command is None)
self.assertEqual(protocols.NODE_ADMIN_ADD_USER,
iq.command.getAttribute('node'))
self.assertEqual('execute', iq.command.getAttribute('action'))
response = toResponse(iq, u'result')
response['to'] = \
self.protocol.xmlstream.factory.authenticator.jid.full()
command = response.addElement((protocols.NS_COMMANDS, u'command'))
command[u'node'] = protocols.NODE_ADMIN_ADD_USER
command[u'status'] = u'executing'
command[u'sessionid'] = u'sid-0'
form = data_form.Form(u'form')
form_type = data_form.Field(u'hidden',
var=u'FORM_TYPE',
value=protocols.NODE_ADMIN)
userjid = data_form.Field(u'jid-single',
var=u'accountjid',
required=True)
password = data_form.Field(u'text-private',
var=u'password',
required=True)
password_verify = data_form.Field(u'text-private',
var=u'password-verify',
required=True)
form.addField(form_type)
form.addField(userjid)
form.addField(password)
form.addField(password_verify)
command.addContent(form.toElement())
self.stub.send(response)
iq = self.stub.output[-1]
self.assertEqual(u'set', iq.getAttribute(u'type'))
self.assertEqual(protocols.NS_COMMANDS, iq.command.uri)
self.assertEqual(protocols.NODE_ADMIN_ADD_USER,
iq.command.getAttribute(u'node'))
self.assertEqual(u'sid-0', iq.command.getAttribute(u'sessionid'))
form = data_form.findForm(iq.command, protocols.NODE_ADMIN)
self.assertEqual(u'submit', form.formType)
self.failUnless(u'accountjid' in form.fields)
self.assertEqual(u'*****@*****.**', form.fields['accountjid'].value)
self.failUnless(u'password' in form.fields)
self.assertEqual(u'secret', form.fields['password'].value)
self.failUnless(u'password-verify' in form.fields)
self.assertEqual(u'secret', form.fields['password-verify'].value)
def test_keys(self):
"""
Getting the keys of a form yields a list of field names.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot'),
data_form.Field('boolean', var='public', value=True),
data_form.Field('list-multi', var='features',
values=['news', 'search'])]
form = data_form.Form('submit', fields=fields)
keys = form.keys()
self.assertIsInstance(keys, list)
self.assertEqual(set(['botname', 'public', 'features']),
set(keys))
def test_getValues(self):
"""
L{Form.getValues} returns a dict of all field values.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot'),
data_form.Field('boolean', var='public', value=True),
data_form.Field('list-multi', var='features',
values=['news', 'search'])]
form = data_form.Form('submit', fields=fields)
self.assertEqual({'botname': 'The Jabber Bot',
'public': True,
'features': ['news', 'search']},
form.getValues())
def test_typeCheckJIDBad(self):
"""
An invalid JID string should raise an exception.
"""
field = data_form.Field(fieldType='jid-single', var='test',
value='test@@example.org')
self.assertRaises(jid.InvalidFormat, field.typeCheck)
def test_typeCheckJID(self):
"""
The value of jid field should be a JID or coercable to one.
"""
field = data_form.Field(fieldType='jid-single', var='test',
value=jid.JID('*****@*****.**'))
field.typeCheck()
def test_typeCheckBooleanBad(self):
"""
A bad value for a boolean field should raise a ValueError
"""
field = data_form.Field(fieldType='boolean', var='test')
field.value = 'test'
self.assertRaises(ValueError, field.typeCheck)
def test_typeCheckTooManyValues(self):
"""
Expect an exception if too many values are set, depending on type.
"""
field = data_form.Field(fieldType='list-single', var='test',
values=[u'value1', u'value2'])
self.assertRaises(data_form.TooManyValuesError, field.typeCheck)
def test_toElementNoType(self):
"""
A field with no type should not have a type attribute.
"""
field = data_form.Field(None, var='test', value='test')
element = field.toElement()
self.assertFalse(element.hasAttribute('type'))
def test_contains(self):
"""
A form contains a known field.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot')]
form = data_form.Form('submit', fields=fields)
self.assertIn('botname', form)
def test_labelAndOptions(self):
"""
The label should be set, even if there are options with labels as dict.
"""
field = data_form.Field(label='test',
options={'test2': 'test 2', 'test3': 'test 3'})
self.assertEqual('test', field.label)
def test_getUnknownDefault(self):
"""
Getting the value of a unknown field returns specified default.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot')]
form = data_form.Form('submit', fields=fields)
self.assertTrue(form.get('public', True))
def test_toElementBooleanTextSingle(self):
"""
A boolean value should render to text if the field type is text-single.
"""
field = data_form.Field(var='test', value=True)
element = field.toElement()
self.assertEqual(u'true', unicode(element.value))
def test_containsNot(self):
"""
A form does not contains an unknown field.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot')]
form = data_form.Form('submit', fields=fields)
self.assertNotIn('features', form)
def test_basic(self):
"""
Test basic field initialization.
"""
field = data_form.Field(var='test')
self.assertEqual('text-single', field.fieldType)
self.assertEqual('test', field.var)
def fillForm(self, user, iq, cmd, form):
form.instructions = ["Select the items you no longer wish to track."]
form.addField(
data_form.Field(var='tracks',
fieldType='list-multi',
options=(data_form.Option(v, v)
for v in sorted(user.tracks))))
def test_get(self):
"""
Getting the value of a known field succeeds.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot')]
form = data_form.Form('submit', fields=fields)
self.assertEqual('The Jabber Bot', form.get('botname'))
def test_getUnknownNone(self):
"""
Getting the value of a unknown field returns None.
"""
fields = [data_form.Field(var='botname', value='The Jabber Bot')]
form = data_form.Form('submit', fields=fields)
self.assertIdentical(None, form.get('features'))
def test_addFieldNamed(self):
"""
A named field should occur in fields.
"""
form = data_form.Form('result')
field = data_form.Field(var='test')
form.addField(field)
self.assertEqual({'test': field}, form.fields)
def test_addFieldNotNamed(self):
"""
A non-named field should not occur in fields.
"""
form = data_form.Form('result')
field = data_form.Field('fixed', value='Section 1')
form.addField(field)
self.assertEqual({}, form.fields)
def test_addField(self):
"""
A field should occur in fieldList.
"""
form = data_form.Form('result')
field = data_form.Field('fixed', value='Section 1')
form.addField(field)
self.assertEqual([field], form.fieldList)
