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_map_binding_operation(
self, mock_operation_namespace, mock_map_binding_operation_messages
):
definitions = Definitions(location="foo.wsdl", target_namespace="xsdata")
operation = BindingOperation(name="Add")
operation.ns_map["foo"] = "bar"
port_operation = PortTypeOperation()
config = {"a": "one", "b": "two", "style": "rpc"}
name = "Calc"
namespace = "SomeNS"
first = ClassFactory.create(qname="some_name_first", meta_name="Envelope")
second = ClassFactory.create(qname="some_name_second", meta_name="Envelope")
other = ClassFactory.create()
service = ClassFactory.create(
qname=build_qname("xsdata", "Calc_Add"),
status=Status.PROCESSED,
type=BindingOperation,
module="foo",
package=None,
ns_map={"foo": "bar"},
attrs=[
DefinitionsMapper.build_attr(
"a", str(DataType.STRING), native=True, default="one"
),
DefinitionsMapper.build_attr(
"b", str(DataType.STRING), native=True, default="two"
),
DefinitionsMapper.build_attr(
"style", str(DataType.STRING), native=True, default="rpc"
),
DefinitionsMapper.build_attr("first", first.qname),
DefinitionsMapper.build_attr("second", second.qname),
],
)
mock_operation_namespace.return_value = namespace
mock_map_binding_operation_messages.return_value = [first, second, other]
result = DefinitionsMapper.map_binding_operation(
definitions, operation, port_operation, config, name
)
expected = [first, second, other, service]
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
mock_operation_namespace.assert_called_once_with(config)
mock_map_binding_operation_messages.assert_called_once_with(
definitions, operation, port_operation, service.name, "rpc", namespace
)
def test_get_or_create_inner_class(self):
target = ClassFactory.create(module="foo",
package=None,
ns_map={"foo": "bar"})
actual = DefinitionsMapper.build_inner_class(target, "body")
expected = ClassFactory.create(
qname="body",
tag=Tag.BINDING_MESSAGE,
module=target.module,
package=None,
ns_map=target.ns_map,
)
self.assertEqual(expected, actual)
self.assertIn(actual, target.inner)
self.assertIsNot(actual.ns_map, target.ns_map)
expected_attr = DefinitionsMapper.build_attr("body",
"body",
forward=True)
self.assertEqual(expected_attr, target.attrs[0])
repeat = DefinitionsMapper.build_inner_class(target, "body")
self.assertIs(repeat, actual)
def test_build_envelope_fault(self):
body = ClassFactory.create(qname="Body")
target = ClassFactory.create()
target.inner.append(body)
port_type_operation = PortTypeOperation()
definitions = Definitions()
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", "detail"]
]
self.assertEqual(1, len(body.attrs))
self.assertEqual(expected_fault_attr, body.attrs[0])
self.assertEqual(expected_fault_attrs, body.inner[0].attrs)
def test_map_port_type_message(self):
port_type_message = PortTypeMessage(message="foo:bar")
port_type_message.ns_map["foo"] = "foobar"
target_namespace = "xsdata"
actual = DefinitionsMapper.map_port_type_message(
port_type_message, target_namespace)
expected = DefinitionsMapper.build_attr("bar",
qname=build_qname(
"foobar", "bar"),
namespace=target_namespace)
self.assertIsInstance(actual, Generator)
self.assertEqual([expected], list(actual))
