def test_from_xso_rejects_mismatching_type(self):
data = forms_xso.Data(type_=forms_xso.DataType.FORM)
data.fields.append(
forms_xso.Field(
var="FORM_TYPE",
type_=forms_xso.FieldType.HIDDEN,
values=["some-uri"],
))
data.fields.append(
forms_xso.Field(
type_=forms_xso.FieldType.FIXED,
values=["This is some heading."],
))
data.fields.append(
forms_xso.Field(
var="jid",
type_=forms_xso.FieldType.JID_SINGLE,
values=[],
desc="some description",
label="some label",
))
class F(form.Form):
jid = fields.TextSingle(var="jid", )
with self.assertRaisesRegex(
ValueError, r"mismatching type (.+ != .+) on field .+"):
F.from_xso(data)
def test_from_xso_complex(self):
data = forms_xso.Data(type_=forms_xso.DataType.FORM)
data.fields.append(
forms_xso.Field(
var="FORM_TYPE",
type_=forms_xso.FieldType.HIDDEN,
values=["some-uri"],
))
data.fields.append(
forms_xso.Field(
type_=forms_xso.FieldType.FIXED,
values=["This is some heading."],
))
data.fields.append(
forms_xso.Field(
var="jid",
type_=forms_xso.FieldType.JID_SINGLE,
values=[],
desc="some description",
label="some label",
))
class F(form.Form):
jid = fields.JIDSingle(var="jid", )
f = F.from_xso(data)
self.assertIsNone(f.jid.value)
self.assertIs(f._recv_xso, data)
def test_from_xso_allows_upcast(self):
data = forms_xso.Data(type_=forms_xso.DataType.FORM)
data.fields.append(
forms_xso.Field(
var="FORM_TYPE",
type_=forms_xso.FieldType.HIDDEN,
values=["some-uri"],
))
data.fields.append(
forms_xso.Field(
type_=forms_xso.FieldType.FIXED,
values=["This is some heading."],
))
data.fields.append(
forms_xso.Field(
var="jid",
type_=forms_xso.FieldType.TEXT_SINGLE,
values=[],
desc="some description",
label="some label",
))
class F(form.Form):
jid = fields.TextPrivate(var="jid", )
F.from_xso(data)
def test_ignore_form_without_type(self):
forms = [
forms_xso.Data(type_=forms_xso.DataType.FORM),
forms_xso.Data(type_=forms_xso.DataType.FORM)
]
forms[0].fields.extend([
forms_xso.Field(var="FORM_TYPE", values=[]),
forms_xso.Field(var="os_version", values=[
"10.5.1",
]),
])
forms[1].fields.extend([
forms_xso.Field(var="FORM_TYPE",
values=[
"urn:xmpp:dataforms:softwareinfo",
]),
forms_xso.Field(var="os_version", values=[
"10.5.1",
]),
forms_xso.Field(var="os", values=[
"Mac",
]),
])
self.assertEqual(
b"urn:xmpp:dataforms:softwareinfo<"
b"os<Mac<"
b"os_version<10.5.1<", caps115.build_forms_string(forms))
def test_message_from_node():
aiomsg = aioxmpp.Message(type_=aioxmpp.MessageType.CHAT)
data = forms_xso.Data(type_=forms_xso.DataType.FORM)
data.fields.append(
forms_xso.Field(
var="performative",
type_=forms_xso.FieldType.TEXT_SINGLE,
values=["request"],
)
)
data.fields.append(
forms_xso.Field(
var="_thread_node",
type_=forms_xso.FieldType.TEXT_SINGLE,
values=["thread-id"],
)
)
data.title = SPADE_X_METADATA
aiomsg.xep0004_data = [data]
msg = Message.from_node(aiomsg)
assert msg.thread == "thread-id"
assert msg.get_metadata("performative") == "request"
assert msg.metadata == {"performative": "request"}
def test_render_reply_includes_unknown_field(self):
data = forms_xso.Data(type_=forms_xso.DataType.FORM)
data.fields.append(
forms_xso.Field(
var="jid",
type_=forms_xso.FieldType.JID_SINGLE,
values=[],
desc="some description",
)
)
data.fields.append(
forms_xso.Field(
var="foo",
type_=forms_xso.FieldType.TEXT_SINGLE,
values=[],
)
)
class F(form.Form):
jid = fields.JIDSingle(
var="jid",
label="Foobar"
)
f = F.from_xso(data)
f.jid.value = aioxmpp.JID.fromstr("*****@*****.**")
result = f.render_reply()
self.assertIsInstance(result, forms_xso.Data)
self.assertEqual(
len(result.fields),
2
)
self.assertIs(
data.fields[1],
result.fields[1]
)
self.assertIsNot(
data.fields[0],
result.fields[0],
)
jid_field = result.fields[0]
self.assertSequenceEqual(
jid_field.values,
["*****@*****.**"]
)
self.assertEqual(
jid_field.desc,
"some description",
)
self.assertIsNone(
jid_field.label
)
def test_render_reply(self):
data = forms_xso.Data(type_=forms_xso.DataType.FORM)
data.fields.append(
forms_xso.Field(
var="FORM_TYPE",
type_=forms_xso.FieldType.HIDDEN,
values=["some-uri"],
))
data.fields.append(
forms_xso.Field(
type_=forms_xso.FieldType.FIXED,
values=["This is some heading."],
))
data.fields.append(
forms_xso.Field(
var="jid",
type_=forms_xso.FieldType.JID_SINGLE,
values=[],
desc="some description",
))
class F(form.Form):
jid = fields.JIDSingle(var="jid", label="Foobar")
other = fields.TextSingle(var="foo", )
f = F.from_xso(data)
f.jid.value = aioxmpp.JID.fromstr("*****@*****.**")
result = f.render_reply()
self.assertIsInstance(result, forms_xso.Data)
self.assertEqual(
result.type_,
forms_xso.DataType.SUBMIT,
)
self.assertEqual(len(result.fields), 3)
self.assertIs(data.fields[0], result.fields[0])
self.assertIs(
data.fields[1],
result.fields[1],
)
self.assertIsNot(
data.fields[2],
result.fields[2],
)
jid_field = result.fields[2]
self.assertSequenceEqual(jid_field.values, ["*****@*****.**"])
self.assertEqual(
jid_field.desc,
"some description",
)
self.assertIsNone(jid_field.label)
def test_get_form_type_copes_with_malformed_FORM_TYPE(self):
d = forms_xso.Data(type_=forms_xso.DataType.FORM)
d.fields.append(forms_xso.Field(), )
d.fields.append(
forms_xso.Field(type_=forms_xso.FieldType.HIDDEN,
var="FORM_TYPE",
values=[]), )
d.fields.append(forms_xso.Field(), )
self.assertIsNone(d.get_form_type(), )
def test_get_form_type_detects_incorrect_FORM_TYPE(self):
d = forms_xso.Data(type_=forms_xso.DataType.FORM)
d.fields.append(forms_xso.Field(), )
d.fields.append(
forms_xso.Field(type_=forms_xso.FieldType.TEXT_SINGLE,
var="FORM_TYPE",
values=[unittest.mock.sentinel.form_type]), )
d.fields.append(forms_xso.Field(), )
self.assertIsNone(d.get_form_type(), )
def test_get_form_type_copes_with_too_many_values(self):
d = forms_xso.Data(type_=forms_xso.DataType.FORM)
d.fields.append(forms_xso.Field(), )
d.fields.append(
forms_xso.Field(type_=forms_xso.FieldType.HIDDEN,
var="FORM_TYPE",
values=["foo", "bar"]), )
d.fields.append(forms_xso.Field(), )
self.assertIsNone(d.get_form_type(), )
def test_get_form_type_returns_none_without_FORM_TYPE(self):
d = forms_xso.Data(type_=forms_xso.DataType.FORM)
d.fields.append(
forms_xso.Field(),
)
d.fields.append(
forms_xso.Field(),
)
self.assertIsNone(
d.get_form_type(),
)
def test_get_form_type(self):
d = forms_xso.Data(type_=forms_xso.DataType.FORM)
d.fields.append(forms_xso.Field(), )
d.fields.append(
forms_xso.Field(type_=forms_xso.FieldType.HIDDEN,
var="FORM_TYPE",
values=[unittest.mock.sentinel.form_type]), )
d.fields.append(forms_xso.Field(), )
self.assertEqual(
d.get_form_type(),
unittest.mock.sentinel.form_type,
)
def test_accept_form_with_multiple_identical_types(self):
forms = [forms_xso.Data(type_=forms_xso.DataType.FORM)]
forms[0].fields.extend([
forms_xso.Field(var="FORM_TYPE",
values=[
"urn:xmpp:dataforms:softwareinfo",
"urn:xmpp:dataforms:softwareinfo",
]),
forms_xso.Field(var="os_version", values=[
"10.5.1",
]),
])
caps115.build_forms_string(forms)
def test_init_args(self):
options = {
"1": "Foo 1",
"2": "Foo 2",
"3": "Foo 3",
}
values = ["1", "2"]
f = forms_xso.Field(type_="list-multi",
options=options,
values=values,
desc="description",
required=True,
label="fnord")
self.assertEqual(f.type_, "list-multi")
self.assertDictEqual(f.options, options)
self.assertIsNot(f.options, options)
self.assertSequenceEqual(f.values, values)
self.assertIsNot(f.values, values)
self.assertEqual(f.desc, "description")
self.assertEqual(f.required, (namespaces.xep0004_data, "required"))
self.assertEqual(f.label, "fnord")
def test_init_args(self):
options = {
"1": "Foo 1",
"2": "Foo 2",
"3": "Foo 3",
}
values = ["1", "2"]
f = forms_xso.Field(
type_=forms_xso.FieldType.LIST_MULTI,
options=options,
values=values,
desc="description",
required=True,
label="fnord"
)
self.assertEqual(f.type_, forms_xso.FieldType.LIST_MULTI)
self.assertDictEqual(f.options, options)
self.assertIsNot(f.options, options)
self.assertSequenceEqual(f.values, values)
self.assertIsNot(f.values, values)
self.assertEqual(f.desc, "description")
self.assertIs(
f.required,
True,
)
self.assertEqual(f.label, "fnord")
def test_validate_accepts_fields_for_results_without_report(self):
field = forms_xso.Field()
field.type_ = forms_xso.FieldType.FIXED
obj = forms_xso.Data(type_=forms_xso.DataType.RESULT)
obj.fields.append(field)
obj.validate()
def test_accept_missing_var_for_fixed_fields(self):
f = forms_xso.Field()
f.type_ = forms_xso.FieldType.FIXED
f.validate()
f.var = "foobar"
f.validate()
def prepare(self):
"""
Returns an aioxmpp.stanza.Message built from the Message and prepared to be sent.
Returns:
aioxmpp.stanza.Message: the message prepared to be sent
"""
msg = aioxmpp.stanza.Message(
to=self.to,
from_=self.sender,
type_=aioxmpp.MessageType.CHAT,
)
msg.body[None] = self.body
msg.thread = self.thread
# Send metadata using xep-0004: Data Forms (https://xmpp.org/extensions/xep-0004.html)
if len(self.metadata):
data = forms_xso.Data(type_=forms_xso.DataType.FORM)
for name, value in self.metadata.items():
data.fields.append(
forms_xso.Field(
var=name,
type_=forms_xso.FieldType.TEXT_SINGLE,
values=[value],
))
data.title = SPADE_X_METADATA
msg.xep0004_data = [data]
return msg
def test_validate_accepts_fields_for_results_without_report(self):
field = forms_xso.Field()
field.type_ = "fixed"
obj = forms_xso.Data()
obj.type_ = "result"
obj.fields.append(field)
obj.validate()
def test_accept_multiple_values_for_None(self):
f = forms_xso.Field()
f.type_ = None
f.var = "foobar"
f.values.append(forms_xso.Value())
f.values.append(forms_xso.Value())
f.validate()
def test_init(self):
f = forms_xso.Field()
self.assertEqual(f.type_, "text-single")
self.assertSequenceEqual(f.values, [])
self.assertDictEqual(f.options, {})
self.assertIsNone(f.required)
self.assertIsNone(f.desc)
self.assertIsNone(f.var)
self.assertIsNone(f.label)
def test_reject_missing_var_for_non_fixed_fields(self):
types = set(forms_xso.FieldType)
types.discard(forms_xso.FieldType.FIXED)
for type_ in types:
f = forms_xso.Field()
f.type_ = type_
with self.assertRaisesRegex(ValueError, "missing attribute var"):
f.validate()
def test_reject_duplicate_option_values(self):
f = forms_xso.Field()
f.type_ = forms_xso.FieldType.LIST_MULTI
f.var = "foobar"
f.options["foo"] = "bar"
f.options["baz"] = "bar"
with self.assertRaisesRegex(ValueError, "duplicate option value"):
f.validate()
def test_validate_reject_mismatching_items(self):
f = forms_xso.Field()
f.var = "foobar"
obj = forms_xso.Data(forms_xso.DataType.RESULT)
obj.reported = forms_xso.Reported()
obj.reported.fields.append(f)
f2 = forms_xso.Field()
f2.var = "fnord"
item = forms_xso.Item()
item.fields.append(f2)
obj.items.append(item)
with self.assertRaisesRegex(ValueError,
"field mismatch between row and header"):
obj.validate()
def test_init(self):
f = forms_xso.Field()
self.assertEqual(f.type_, forms_xso.FieldType.TEXT_SINGLE)
self.assertSequenceEqual(f.values, [])
self.assertDictEqual(f.options, {})
self.assertFalse(f.required)
self.assertIsNone(f.desc)
self.assertIsNone(f.var)
self.assertIsNone(f.label)
def test_allow_duplicate_Nones_in_option_labels(self):
f = forms_xso.Field()
f.type_ = forms_xso.FieldType.LIST_MULTI
f.var = "foobar"
f.options["foo"] = "bar"
f.options["baz"] = None
f.options["fnord"] = None
f.validate()
def test_reject_form_with_multiple_different_types(self):
forms = [forms_xso.Data(type_=forms_xso.DataType.FORM)]
forms[0].fields.extend([
forms_xso.Field(var="FORM_TYPE",
values=[
"urn:xmpp:dataforms:softwareinfo",
"urn:xmpp:dataforms:softwarefoo",
]),
forms_xso.Field(var="os_version", values=[
"10.5.1",
]),
forms_xso.Field(var="os", values=[
"Mac",
]),
])
with self.assertRaisesRegex(ValueError, "form with multiple types"):
caps115.build_forms_string(forms)
def test_value_and_var_escaping(self):
forms = [forms_xso.Data(type_=forms_xso.DataType.FORM)]
forms[0].fields.extend([
forms_xso.Field(var="FORM_TYPE",
values=[
"urn:xmpp:<dataforms:softwareinfo",
]),
forms_xso.Field(var="os_version", values=[
"10.&5.1",
]),
forms_xso.Field(var="os>", values=[
"Mac",
]),
])
self.assertEqual(
b"urn:xmpp:<dataforms:softwareinfo<"
b"os><Mac<"
b"os_version<10.&5.1<", caps115.build_forms_string(forms))
def test_accept_options_for_None(self):
option = forms_xso.Option()
option.value = "foobar"
f = forms_xso.Field()
f.type_ = None
f.var = "foobar"
f.options["foo"] = "bar"
f.validate()
def test_multiple(self):
forms = [
forms_xso.Data(type_=forms_xso.DataType.FORM),
forms_xso.Data(type_=forms_xso.DataType.FORM)
]
forms[0].fields.extend([
forms_xso.Field(var="FORM_TYPE", values=[
"uri:foo",
]),
])
forms[1].fields.extend([
forms_xso.Field(var="FORM_TYPE", values=[
"uri:bar",
]),
])
self.assertEqual(b"uri:bar<uri:foo<",
caps115.build_forms_string(forms))
