def test_build_parts_attributes(self, mock_warning):
p_one = Part(element="a:bar")
p_one.ns_map["a"] = "great"
p_two = Part(name="arg0", type="xs:string")
p_two.ns_map["xs"] = Namespace.XS.uri
p_three = Part(name="arg1", type="b:cafe")
p_three.ns_map["b"] = "boo"
p_four = Part(name="arg2")
ns_map = {}
parts = [p_one, p_two, p_three, p_four]
result = DefinitionsMapper.build_parts_attributes(parts, ns_map)
expected = [
DefinitionsMapper.build_attr("bar",
build_qname("great", "bar"),
namespace="great",
native=False),
DefinitionsMapper.build_attr("arg0",
str(DataType.STRING),
namespace="",
native=True),
DefinitionsMapper.build_attr("arg1",
build_qname("boo", "cafe"),
namespace="",
native=False),
]
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
mock_warning.assert_called_once_with("Skip untyped message part %s",
"arg2")
def test_map_binding_message_parts_with_original_message(
self, mock_find_message, mock_create_message_attributes):
definitions = Definitions
message_name = "foo:bar"
ns_map = {}
message = Message(
name="session",
parts=[
Part(name="token", element="foo:token"),
Part(name="messageId", type="id"),
Part(name="another", type="id"),
],
)
extended = AnyElement()
mock_create_message_attributes.return_value = AttrFactory.list(2)
mock_find_message.return_value = message
actual = DefinitionsMapper.map_binding_message_parts(
definitions, message_name, extended, ns_map)
self.assertIsInstance(actual, Generator)
self.assertEqual(2, len(list(actual)))
mock_create_message_attributes.assert_called_once_with(
message.parts, ns_map)
mock_find_message.assert_called_once_with("bar")
def test_build_envelope_fault_with_detail_messages(self):
body = ClassFactory.create(qname="Body")
target = ClassFactory.create()
target.inner.append(body)
port_type_operation = PortTypeOperation()
port_type_operation.faults.append(PortTypeMessage(message="x:foo"))
port_type_operation.faults.append(PortTypeMessage(message="x:bar"))
definitions = Definitions()
definitions.messages.append(
Message(name="foo", parts=[Part(element="fooEl")]))
definitions.messages.append(
Message(name="bar", parts=[Part(element="barEl")]))
DefinitionsMapper.build_envelope_fault(definitions,
port_type_operation, target)
expected_fault_attr = DefinitionsMapper.build_attr(
"Fault",
body.inner[0].qname,
forward=True,
namespace=target.namespace)
str_qname = str(DataType.STRING)
expected_fault_attrs = [
DefinitionsMapper.build_attr(name,
str_qname,
native=True,
namespace="")
for name in ["faultcode", "faultstring", "faultactor"]
]
expected_fault_attrs.append(
DefinitionsMapper.build_attr("detail",
body.inner[0].inner[0].qname,
forward=True,
namespace=""))
expected_fault_detail_attrs = [
DefinitionsMapper.build_attr(name,
qname=name,
namespace=target.namespace,
native=False)
for name in ["fooEl", "barEl"]
]
self.assertEqual(1, len(body.attrs))
self.assertEqual(expected_fault_attr, body.attrs[0])
self.assertEqual(expected_fault_attrs, body.inner[0].attrs)
self.assertEqual(expected_fault_detail_attrs,
body.inner[0].inner[0].attrs)
def test_build_message_class(self, mock_create_message_attributes):
message = Message(name="bar", parts=[Part()])
message.ns_map["foo"] = "bar"
definitions = Definitions(
messages=[message], target_namespace="xsdata", location="foo.wsdl"
)
port_type_message = PortTypeMessage(message="foo:bar")
attrs = AttrFactory.list(2)
mock_create_message_attributes.return_value = attrs
actual = DefinitionsMapper.build_message_class(definitions, port_type_message)
expected = Class(
qname=build_qname("xsdata", "bar"),
status=Status.PROCESSED,
type=Element,
module="foo",
ns_map=message.ns_map,
attrs=attrs,
)
self.assertEqual(expected, actual)