def test_unique_operations(self):
binding = Binding(
type="foo",
operations=[
BindingOperation(name="bar"),
BindingOperation(name="bar"),
BindingOperation(name="bar"),
BindingOperation(name="foo"),
],
)
operations = list(binding.unique_operations())
self.assertEqual(2, len(operations))
self.assertEqual(binding.operations[2], operations[0])
self.assertEqual(binding.operations[3], operations[1])
def test_merge(self):
target = Definitions()
source = Definitions()
source.types = Types()
source.messages.append(Message())
source.port_types.append(PortType())
source.bindings.append(Binding())
source.services.append(Service())
source.extended.append(AnyElement())
source_two = copy.deepcopy(source)
source_two.types.schemas.append(Schema())
target.merge(source)
self.assertEqual(source.types, target.types)
self.assertEqual(0, len(target.types.schemas))
self.assertEqual(1, len(target.messages))
self.assertEqual(1, len(target.port_types))
self.assertEqual(1, len(target.bindings))
self.assertEqual(1, len(target.services))
self.assertEqual(1, len(target.extended))
target.merge(source_two)
target.merge(Definitions())
self.assertEqual(1, len(target.types.schemas))
self.assertEqual(2, len(target.messages))
self.assertEqual(2, len(target.port_types))
self.assertEqual(2, len(target.bindings))
self.assertEqual(2, len(target.services))
self.assertEqual(2, len(target.extended))
def test_map_port(
self, mock_find_binding, mock_find_port_type, mock_attributes, mock_map_binding
):
definitions = Definitions()
service_port = ServicePort(binding="zaa:port", extended=[AnyElement()])
port_type = PortType(name="Calc")
binding = Binding(
type="zaa:zoo",
extended=[AnyElement()],
operations=[BindingOperation(name="ADD"), BindingOperation(name="SUB")],
)
classes = ClassFactory.list(2)
cfg = {
"style": "document",
"location": "http://endpoint.stub/action",
"transport": "public",
}
mock_find_binding.return_value = binding
mock_find_port_type.return_value = port_type
mock_map_binding.return_value = classes
mock_attributes.return_value = cfg
result = DefinitionsMapper.map_port(definitions, service_port)
self.assertIsInstance(result, Generator)
self.assertEqual(classes, list(result))
mock_find_binding.assert_called_once_with("port")
mock_find_port_type.assert_called_once_with("zoo")
self.assertEqual(2, len(list(mock_attributes.call_args[0][0])))
self.assertEqual(1, mock_attributes.call_count)
mock_map_binding.assert_called_once_with(definitions, binding, port_type, cfg)
def test_map_binding(self, mock_attributes, mock_find_operation,
mock_map_binding_operation):
definitions = Definitions()
port_type = PortType(name="Calc")
binding = Binding(
type="zaa:zoo",
operations=[
BindingOperation(name="ADD"),
BindingOperation(name="SUB")
],
)
port_type_add = PortTypeOperation(name="PortAdd")
port_type_sub = PortTypeOperation(name="PortSub")
classes = [
ClassFactory.list(2),
ClassFactory.list(2),
]
mock_map_binding_operation.side_effect = classes
mock_find_operation.side_effect = [port_type_add, port_type_sub]
mock_attributes.side_effect = [
{
"soapAction": "add"
},
{
"soapAction": "sub"
},
]
config = {"foo": "bar"}
result = DefinitionsMapper.map_binding(definitions, binding, port_type,
config)
self.assertIsInstance(result, Generator)
self.assertEqual(classes[0] + classes[1], list(result))
mock_find_operation.assert_has_calls(
[mock.call("ADD"), mock.call("SUB")])
self.assertEqual(2, mock_attributes.call_count)
config_add = {"soapAction": "add", **config}
config_sub = {"soapAction": "sub", **config}
mock_map_binding_operation.assert_has_calls([
mock.call(
definitions,
binding.operations[0],
port_type_add,
config_add,
"Calc",
),
mock.call(
definitions,
binding.operations[1],
port_type_sub,
config_sub,
"Calc",
),
])
def test_find_binding(self):
res = Binding(name="foo")
obj = Definitions(bindings=[res])
self.assertEqual(res, obj.find_binding("foo"))
with self.assertRaises(DefinitionsValueError) as cm:
obj.find_binding("nope")
self.assertEqual("Unknown Binding name: nope", str(cm.exception))
def map_binding(
cls,
definitions: Definitions,
binding: Binding,
port_type: PortType,
config: Dict,
) -> Iterator[Class]:
"""Step 3: Match every BindingOperation to a PortTypeOperation and
delegate the process for each operation to the next entry point."""
for operation in binding.unique_operations():
cfg = config.copy()
cfg.update(cls.attributes(operation.extended_elements))
port_operation = port_type.find_operation(operation.name)
yield from cls.map_binding_operation(definitions, operation,
port_operation, cfg,
port_type.name)
def test_process_definitions(
self,
mock_parse_definitions,
mock_convert_definitions,
mock_convert_schema,
):
uris = [
"http://xsdata/services.wsdl",
"http://xsdata/abstractServices.wsdl",
"http://xsdata/notfound.wsdl",
]
fist_def = Definitions(types=Types(schemas=[Schema(), Schema()]))
second_def = Definitions(bindings=[Binding()])
mock_parse_definitions.side_effect = [fist_def, second_def, None]
self.transformer.process_definitions(uris)
mock_convert_schema.assert_has_calls(
[mock.call(x) for x in fist_def.schemas])
mock_parse_definitions.assert_has_calls([
mock.call(uris[0], namespace=None),
mock.call(uris[1], namespace=None)
])
mock_convert_definitions.assert_called_once_with(fist_def)