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_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))
def test_map_binding_operation_messages_with_style_rpc( self, mock_build_envelope_class, mock_build_message_class): definitions = Definitions() operation = BindingOperation() port_operation = PortTypeOperation() name = "Add" namespace = "someNS" target = ClassFactory.create() message = ClassFactory.create() style = "rpc" mock_build_message_class.return_value = message mock_build_envelope_class.return_value = target operation.input = BindingMessage() port_operation.input = PortTypeMessage() result = DefinitionsMapper.map_binding_operation_messages( definitions, operation, port_operation, name, style, namespace) self.maxDiff = None self.assertEqual([message, target], list(result)) mock_build_message_class.assert_called_once_with( definitions, port_operation.input) mock_build_envelope_class.assert_called_once_with( definitions, operation.input, port_operation.input, f"{name}_input", style, namespace, )
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)
def test_build_envelope_class_with_style_rpc( self, mock_get_or_create_inner_class, mock_map_binding_message_parts, mock_map_port_type_message, ): mock_get_or_create_inner_class.side_effect = mock_create_inner mock_map_binding_message_parts.side_effect = mock_create_attr mock_map_port_type_message.side_effect = mock_create_attr name = "some_operation_bindings" style = "rpc" namespace = "xsdata" definitions = Definitions(location="foo.wsdl", target_namespace="bar") port_type_message = PortTypeMessage(message="some_operation") binding_message = BindingMessage(extended=[ AnyElement(qname="body", attributes={"namespace": "bodyns"}), AnyElement(qname="header"), AnyElement(qname="header"), ]) binding_message.ns_map["foo"] = "bar" result = DefinitionsMapper.build_envelope_class( definitions, binding_message, port_type_message, name, style, namespace) expected = Class( qname=build_qname("bar", name), meta_name="Envelope", tag=Tag.BINDING_MESSAGE, module="foo", ns_map={"foo": "bar"}, namespace="xsdata", ) self.assertEqual(2, len(result.inner)) self.assertEqual(1, len(result.inner[0].attrs)) self.assertEqual(2, len(result.inner[1].attrs)) self.maxDiff = None mock_map_port_type_message.assert_called_once_with( port_type_message, "bodyns") mock_map_binding_message_parts.assert_has_calls([ mock.call( definitions, port_type_message.message, binding_message.extended[1], result.inner[1].ns_map, ), mock.call( definitions, port_type_message.message, binding_message.extended[2], result.inner[1].ns_map, ), ]) mock_get_or_create_inner_class.assert_has_calls([ mock.call(mock.ANY, "Body"), mock.call(mock.ANY, "Header"), mock.call(mock.ANY, "Header"), ]) result.inner.clear() self.assertEqual(expected, result)
def test_map_binding_operation_messages(self, mock_build_envelope_class, mock_build_envelope_fault): definitions = Definitions() operation = BindingOperation() port_operation = PortTypeOperation() name = "Add" namespace = "someNS" target = ClassFactory.create() style = "document" mock_build_envelope_class.return_value = target result = DefinitionsMapper.map_binding_operation_messages( definitions, operation, port_operation, name, style, namespace) self.assertIsInstance(result, Generator) self.assertEqual(0, len(list(result))) operation.input = BindingMessage() port_operation.input = PortTypeMessage() result = DefinitionsMapper.map_binding_operation_messages( definitions, operation, port_operation, name, style, namespace) self.maxDiff = None self.assertEqual([target], list(result)) operation.output = BindingMessage() port_operation.output = PortTypeMessage() result = DefinitionsMapper.map_binding_operation_messages( definitions, operation, port_operation, name, style, namespace) self.assertEqual([target, target], list(result)) mock_build_envelope_class.assert_has_calls([ mock.call( definitions, operation.input, port_operation.input, f"{name}_input", style, namespace, ), mock.call( definitions, operation.input, port_operation.input, f"{name}_input", style, namespace, ), mock.call( definitions, operation.output, port_operation.output, f"{name}_output", style, namespace, ), ]) mock_build_envelope_fault.assert_called_once_with( definitions, port_operation, target)
def test_build_envelope_class( self, mock_get_or_create_inner_class, mock_map_binding_message_parts, mock_map_port_type_message, ): mock_get_or_create_inner_class.side_effect = mock_create_inner mock_map_binding_message_parts.side_effect = mock_create_attr name = "some_operation_bindings" style = "document" namespace = "xsdata" definitions = Definitions(location="foo.wsdl", target_namespace="bar") port_type_message = PortTypeMessage(message="some_operation") binding_message = BindingMessage( extended=[ AnyElement(qname="body"), AnyElement(qname="header"), AnyElement(qname="header"), ] ) binding_message.ns_map["foo"] = "bar" result = DefinitionsMapper.build_envelope_class( definitions, binding_message, port_type_message, name, style, namespace ) expected = Class( qname=build_qname("bar", name), meta_name="Envelope", type=BindingMessage, module="foo", ns_map={"foo": "bar"}, namespace="xsdata", ) self.assertEqual(2, len(result.inner)) self.assertEqual(1, len(result.inner[0].attrs)) self.assertEqual(2, len(result.inner[1].attrs)) self.assertEqual(0, mock_map_port_type_message.call_count) mock_map_binding_message_parts.assert_has_calls( [ mock.call( definitions, port_type_message.message, binding_message.extended[0], result.inner[0].ns_map, ), mock.call( definitions, port_type_message.message, binding_message.extended[1], result.inner[1].ns_map, ), mock.call( definitions, port_type_message.message, binding_message.extended[2], result.inner[1].ns_map, ), ] ) mock_get_or_create_inner_class.assert_has_calls( [ mock.call(mock.ANY, "Body"), mock.call(mock.ANY, "Header"), mock.call(mock.ANY, "Header"), ] ) result.inner.clear() self.assertEqual(expected, result)