def test_add_to_schema_no_extends(self):
from spyne.const.xml import XSD
class cls(Fault):
__namespace__='ns'
@classmethod
def get_type_name_ns(self, app):
return 'testing:My'
interface = Interface(FakeApp())
interface.add_class(cls)
pref = cls.get_namespace_prefix(interface)
wsdl = Wsdl11(interface)
wsdl.build_interface_document('prot://addr')
schema = wsdl.get_schema_info(pref)
self.assertEqual(len(schema.types), 1)
c_cls = interface.classes['{ns}cls']
c_elt = schema.types[0]
self.assertTrue(c_cls is cls)
self.assertEqual(c_elt.tag, XSD('complexType'))
self.assertEqual(c_elt.get('name'), 'cls')
self.assertEqual(len(schema.elements), 1)
e_elt = schema.elements.values()[0]
self.assertEqual(e_elt.tag, XSD('element'))
self.assertEqual(e_elt.get('name'), 'cls')
self.assertEqual(e_elt.get('type'), 'testing:My')
self.assertEqual(len(e_elt), 0)
def __init__(self, services, tns, name=None,
in_protocol=None, out_protocol=None, interface=None):
self.services = tuple(services)
self.tns = tns
self.name = name
if self.name is None:
self.name = self.__class__.__name__.split('.')[-1]
self.event_manager = EventManager(self)
self.error_handler = None
self.interface = Interface(self)
self.in_protocol = in_protocol
self.out_protocol = out_protocol
if self.in_protocol is None:
from spyne.protocol import ProtocolBase
self.in_protocol = ProtocolBase(self)
else:
self.in_protocol.set_app(self)
if self.out_protocol is None:
from spyne.protocol import ProtocolBase
self.out_protocol = ProtocolBase(self)
else:
self.out_protocol.set_app(self)
register_application(self)
self.reinitialize()
def __init__(self,
services,
tns,
name=None,
prefix_namespace=None,
names_parts_in_messages=None,
in_protocol=None,
out_protocol=None,
config=None,
classes=()):
self.services = tuple(services)
self.tns = tns
self.name = name
self.config = config
self.classes = classes
self.names_parts_in_messages = names_parts_in_messages
if prefix_namespace is None:
self.prefix_namespace = DEFAULT_PREFIX_NAMESPACE
else:
self.prefix_namespace = prefix_namespace
if self.name is None:
self.name = self.__class__.__name__.split('.')[-1]
logger.info("Initializing application {%s}%s...", self.tns, self.name)
self.event_manager = EventManager(self)
self.error_handler = None
self.in_protocol = in_protocol
self.out_protocol = out_protocol
if self.in_protocol is None:
from spyne.protocol import ProtocolBase
self.in_protocol = ProtocolBase()
if self.out_protocol is None:
from spyne.protocol import ProtocolBase
self.out_protocol = ProtocolBase()
self.check_unique_method_keys() # is this really necessary nowadays?
# this needs to be after protocol assignments to give _static_when
# functions as much info as possible about the application
self.interface = Interface(self)
# set_app needs to be after interface init because the protocols use it.
self.in_protocol.set_app(self)
# FIXME: this normally is another parameter to set_app but it's kept
# separate for backwards compatibility reasons.
self.in_protocol.message = self.in_protocol.REQUEST
self.out_protocol.set_app(self)
# FIXME: this normally is another parameter to set_app but it's kept
# separate for backwards compatibility reasons.
self.out_protocol.message = self.out_protocol.RESPONSE
register_application(self)
def get_schema_documents(models, default_namespace=None):
"""Returns the schema documents in a dict whose keys are namespace prefixes
and values are Element objects.
:param models: A list of spyne.model classes that will be represented in
the schema.
"""
if default_namespace is None:
default_namespace = models[0].get_namespace()
fake_app = FakeApplication()
fake_app.tns = default_namespace
fake_app.services = []
interface = Interface(fake_app)
for m in models:
m.resolve_namespace(m, default_namespace)
interface.add_class(m)
interface.populate_interface(fake_app)
document = XmlSchema(interface)
document.build_interface_document()
return document.get_interface_document()
def __init__(self, services, tns, name=None,
in_protocol=None, out_protocol=None, interface=None):
self.services = tuple(services)
self.tns = tns
self.name = name
if self.name is None:
self.name = self.__class__.__name__.split('.')[-1]
self.event_manager = EventManager(self)
self.error_handler = None
self.interface = Interface(self)
self.in_protocol = in_protocol
self.out_protocol = out_protocol
if self.in_protocol is None:
from spyne.protocol import ProtocolBase
self.in_protocol = ProtocolBase()
self.in_protocol.set_app(self)
# FIXME: this normally is another parameter to set_app but it's kept
# separate for backwards compatibility reasons.
self.in_protocol.message = self.in_protocol.REQUEST
if self.out_protocol is None:
from spyne.protocol import ProtocolBase
self.out_protocol = ProtocolBase()
self.out_protocol.set_app(self)
# FIXME: this normally is another parameter to set_app but it's kept
# separate for backwards compatibility reasons.
self.out_protocol.message = self.out_protocol.RESPONSE
register_application(self)
self.reinitialize()
def test_add_to_schema_w_extends(self):
import spyne.const.xml_ns
ns_xsd = spyne.const.xml_ns.xsd
class base(Fault):
__namespace__ = 'ns'
@classmethod
def get_type_name_ns(self, app):
return 'testing:Base'
class cls(Fault):
__namespace__ = 'ns'
@classmethod
def get_type_name_ns(self, app):
return 'testing:My'
interface = Interface(FakeApp())
interface.add_class(cls)
pref = cls.get_namespace_prefix(interface)
wsdl = Wsdl11(interface)
wsdl.build_interface_document('prot://addr')
schema = wsdl.get_schema_info(pref)
self.assertEqual(len(schema.types), 1)
self.assertEqual(len(interface.classes), 1)
c_cls = interface.classes.values()[0]
c_elt = schema.types.values()[0]
print(c_cls, cls)
self.failUnless(c_cls is cls)
self.assertEqual(c_elt.tag, '{%s}complexType' % ns_xsd)
self.assertEqual(c_elt.get('name'), 'Fault')
self.assertEqual(len(c_elt), 0)
def get_validation_schema(models, default_namespace=None):
"""Returns the validation schema object for the given models.
:param models: A list of spyne.model classes that will be represented in
the schema.
"""
if default_namespace is None:
default_namespace = models[0].get_namespace()
fake_app = FakeApplication(default_namespace)
interface = Interface(fake_app)
for m in models:
m.resolve_namespace(m, default_namespace)
interface.add_class(m)
schema = XmlSchema(interface)
schema.build_validation_schema()
return schema.validation_schema
def test_add_to_schema(self):
class CM(ComplexModel):
i = Integer
s = String
a = XmlAttribute(String)
app = FakeApp()
app.tns = 'tns'
CM.resolve_namespace(CM, app.tns)
interface = Interface(app)
interface.add_class(CM)
wsdl = Wsdl11(interface)
wsdl.build_interface_document('http://a-aaaa.com')
pref = CM.get_namespace_prefix(interface)
type_def = wsdl.get_schema_info(pref).types[CM.get_type_name()]
attribute_def = type_def.find('{%s}attribute' % xml_ns.xsd)
print(etree.tostring(type_def, pretty_print=True))
self.assertIsNotNone(attribute_def)
self.assertEqual(attribute_def.get('name'), 'a')
self.assertEqual(attribute_def.get('type'), CM.a.type.get_type_name_ns(interface))
def get_validation_schema(models, default_namespace=None):
'''Returns the validation schema object for the given models.
:param models: A list of spyne.model classes that will be represented in
the schema.
'''
if default_namespace is None:
default_namespace = models[0].get_namespace()
fake_app = FakeApplication()
fake_app.tns = default_namespace
fake_app.services = []
interface = Interface(fake_app)
for m in models:
interface.add_class(m)
schema = XmlSchema(interface)
schema.build_validation_schema()
return schema.validation_schema
def test_add_to_schema_w_extends(self):
from spyne.const.xml import XSD
class base(Fault):
__namespace__ = 'ns'
@classmethod
def get_type_name_ns(self, app):
return 'testing:Base'
class cls(Fault):
__namespace__ = 'ns'
@classmethod
def get_type_name_ns(self, app):
return 'testing:My'
interface = Interface(FakeApp())
interface.add_class(cls)
pref = cls.get_namespace_prefix(interface)
wsdl = Wsdl11(interface)
wsdl.build_interface_document('prot://addr')
schema = wsdl.get_schema_info(pref)
self.assertEqual(len(schema.types), 1)
self.assertEqual(len(interface.classes), 1)
c_cls = next(iter(interface.classes.values()))
c_elt = next(iter(schema.types.values()))
self.failUnless(c_cls is cls)
self.assertEqual(c_elt.tag, XSD('complexType'))
self.assertEqual(c_elt.get('name'), 'cls')
from lxml import etree
print(etree.tostring(c_elt, pretty_print=True))
self.assertEqual(len(c_elt), 0)
