class SomeService(Service):
@srpc(Array(String), _returns=Array(String))
def whatever(sa):
return sa
@srpc(Array(String), _returns=Array(String), _body_style='bare')
def whatever_bare(sa):
return sa
def test_class_array(self):
peeps = []
names = ['bob', 'jim', 'peabody', 'mumblesleeves']
dob = datetime.datetime(1979, 1, 1)
for name in names:
a = Person()
a.name = name
a.birthdate = dob
a.age = 27
peeps.append(a)
type = Array(Person)
type.resolve_namespace(type, __name__)
element = etree.Element('test')
XmlDocument().to_parent_element(type, peeps, ns_test, element)
element = element[0]
self.assertEquals(4, len(element.getchildren()))
peeps2 = XmlDocument().from_element(type, element)
for i in range(0, 4):
self.assertEquals(peeps2[i].name, names[i])
self.assertEquals(peeps2[i].birthdate, dob)
def test_class_nested_array(self):
peeps = []
names = ['bob', 'jim', 'peabody', 'mumblesleves']
for name in names:
a = Person()
a.name = name
a.birthdate = datetime.datetime(1979, 1, 1)
a.age = 27
a.addresses = []
for i in range(0, 25):
addr = Address()
addr.street = '555 downtown'
addr.city = 'funkytown'
a.addresses.append(addr)
peeps.append(a)
type = Array(Person)
type.resolve_namespace(type, __name__)
element = etree.Element('test')
XmlDocument().to_parent_element(type, peeps, ns_test, element)
element = element[0]
self.assertEquals(4, len(element.getchildren()))
peeps2 = XmlDocument().from_element(type, element)
for peep in peeps2:
self.assertEquals(27, peep.age)
self.assertEquals(25, len(peep.addresses))
self.assertEquals('funkytown', peep.addresses[18].city)
class Flight(ComplexModel):
__namespace__ = 'testing'
Index = Integer(min_occurs=0, max_occurs=1, nillable=True)
flightNumber = Unicode(min_occurs=0, max_occurs=1, nillable=True)
airline = Unicode(min_occurs=0, max_occurs=1, nillable=True)
airlineIATA = Unicode(min_occurs=0, max_occurs=1, nillable=True)
flightNumber = Unicode(min_occurs=0, max_occurs=1, nillable=True)
nChild = Integer(min_occurs=0, max_occurs=1, nillable=True)
nInfant = Integer(min_occurs=0, max_occurs=1, nillable=True)
arrivalDateTime = DateTime(min_occurs=0, max_occurs=1, nillable=True)
from_ = Unicode(min_occurs=0, max_occurs=1, nillable=False)
to = Unicode(min_occurs=0, max_occurs=1, nillable=False)
departureDatetime = DateTime(min_occurs=0, max_occurs=1, nillable=False)
nAdult = Integer(min_occurs=0, max_occurs=1, nillable=False)
AV = Array(AV.customize(nillable=True))
LConnections = Array(Connection.customize(nillable=True))
LFares = Array(Fare.customize(nillable=True))
validReturns = Array(Unicode(min_occurs=0, max_occurs=1, nillable=False))
type = Unicode(min_occurs=0, max_occurs=1, nillable=False)
return_ = Boolean(min_occurs=0, max_occurs=1, nillable=False)
schedule = Unicode(min_occurs=0, max_occurs=1, nillable=False)
range = Unicode(min_occurs=0, max_occurs=1, nillable=False)
info = Unicode(min_occurs=0, max_occurs=1, nillable=False)
def test_class_array(self):
peeps = []
names = ["bob", "jim", "peabody", "mumblesleves"]
dob = datetime.datetime(1979, 1, 1)
for name in names:
a = Person()
a.name = name
a.birthdate = dob
a.age = 27
peeps.append(a)
type = Array(Person)
type.resolve_namespace(type, __name__)
element = etree.Element("test")
XmlObject().to_parent_element(type, peeps, ns_test, element)
element = element[0]
self.assertEquals(4, len(element.getchildren()))
peeps2 = XmlObject().from_element(type, element)
for i in range(0, 4):
self.assertEquals(peeps2[i].name, names[i])
self.assertEquals(peeps2[i].birthdate, dob)
def test_class_nested_array(self):
peeps = []
names = ["bob", "jim", "peabody", "mumblesleves"]
for name in names:
a = Person()
a.name = name
a.birthdate = datetime.datetime(1979, 1, 1)
a.age = 27
a.addresses = []
for i in range(0, 25):
addr = Address()
addr.street = "555 downtown"
addr.city = "funkytown"
a.addresses.append(addr)
peeps.append(a)
type = Array(Person)
type.resolve_namespace(type, __name__)
element = etree.Element("test")
XmlObject().to_parent_element(type, peeps, ns_test, element)
element = element[0]
self.assertEquals(4, len(element.getchildren()))
peeps2 = XmlObject().from_element(type, element)
for peep in peeps2:
self.assertEquals(27, peep.age)
self.assertEquals(25, len(peep.addresses))
self.assertEquals("funkytown", peep.addresses[18].city)
class Person(ComplexModel):
__namespace__ = "TestService"
name = String
birthdate = DateTime
age = Integer
addresses = Array(Address)
titles = Array(String)
class InteropBare(ServiceBase):
@srpc(String, _returns=String, _body_style='bare')
def echo_simple_bare(ss):
return ss
@srpc(Array(String), _returns=Array(String), _body_style='bare')
def echo_complex_bare(ss):
return ss
class InteropMisc(ServiceBase):
@srpc(_returns=[
Integer, String, Integer,
Array(Enum("MEMBER", type_name="RoleEnum"))
],
_out_variable_names=[
'resultCode', 'resultDescription', 'transactionId', 'roles'
])
def complex_return():
return [1, "Test", 123, ["MEMBER"]]
@srpc(_returns=Integer)
def huge_number():
return 2**int(1e5)
@srpc(_returns=String)
def long_string():
return ('0123456789abcdef' * 16384)
@srpc()
def test_empty():
pass
@srpc(String, Integer, DateTime)
def multi_param(s, i, dt):
pass
@srpc(NonNillableClass, _returns=String)
def non_nillable(n):
return "OK"
@srpc(String, _returns=String, _operation_name="do_something")
def do_something_else(s):
return s
@srpc(Integer, _returns=Array(OtherClass))
def return_other_class_array(num):
for i in range(num):
yield OtherClass(dt=datetime(2010, 12, 6), d=3.0, b=True)
@srpc(_returns=Attachment)
def return_binary_data():
return Attachment(data=''.join([chr(i) for i in range(256)]))
@srpc(_returns=Integer)
def return_invalid_data():
return 'a'
@srpc(
String,
# FIXME: find out why this could be needed
# _public_name="urn:#getCustomMessages",
_in_message_name="getCustomMessagesMsgIn",
_out_message_name="getCustomMessagesMsgOut",
_out_variable_name="CustomMessages",
_returns=String)
def custom_messages(s):
return s
class NestedClass(ComplexModel):
__namespace__ = "punk.tunk"
simple = Array(SimpleClass)
s = String
i = Integer
f = Float
other = OtherClass
ai = Array(Integer)
def test_array(self):
type = Array(String)
type.resolve_namespace(type, "zbank")
values = ['a', 'b', 'c', 'd', 'e', 'f']
element = etree.Element('test')
XmlDocument().to_parent_element(type, values, ns_test, element)
element = element[0]
self.assertEquals(len(values), len(element.getchildren()))
values2 = XmlDocument().from_element(type, element)
self.assertEquals(values[3], values2[3])
def test_array_empty(self):
type = Array(String)
type.resolve_namespace(type, "zbank")
values = []
element = etree.Element('test')
XmlDocument().to_parent(None, type, values, element, ns_test)
element = element[0]
self.assertEquals(len(values), len(element.getchildren()))
values2 = XmlDocument().from_element(None, type, element)
self.assertEquals(len(values2), 0)
def test_array(self):
type = Array(String)
type.resolve_namespace(type, "zbank")
values = ['a', 'b', 'c', 'd', 'e', 'f']
element = etree.Element('test')
XmlObject().to_parent_element(type, values, ns_test, element)
element = element[0]
self.assertEquals(len(values), len(element.getchildren()))
values2 = XmlObject().from_element(type, element)
self.assertEquals(values[3], values2[3])
def test_array_empty(self):
type = Array(String)
type.resolve_namespace(type, "zbank")
values = []
element = etree.Element('test')
XmlDocument().to_parent(None, type, values, element, ns_test)
element = element[0]
self.assertEquals(len(values), len(element.getchildren()))
values2 = XmlDocument().from_element(None, type, element)
self.assertEquals(len(values2), 0)
class InfoOutput(ComplexModel):
"""
Return type of SOAP method info.
"""
__namespace__ = SOAP_NAMESPACE
version = Unicode
versionParts = Array(Unicode)
releaseDate = Unicode
nomenclatureVersion = Unicode
nomenclatureVersionParts = Array(Unicode)
serverName = Unicode
contactEmail = Unicode
announcement = Unicode
announcementUrl = Unicode
class SomeClass(NewTableModel):
__tablename__ = 'some_class'
__table_args__ = {"sqlite_autoincrement": True}
id = Integer32(primary_key=True)
others = Array(SomeOtherClass,
store_as=table(multi=True, backref='some_classes'))
class SomeClass(NewTableModel):
__tablename__ = 'some_class'
__table_args__ = {"sqlite_autoincrement": True}
id = Integer32(primary_key=True)
others = Array(SomeOtherClass, store_as='json')
f = Unicode(32, default='uuu')
class ComplexShiftsResponseSoapModel(ComplexModel):
__namespace__ = NAMESPACE
__type_name__ = "shiftsresponseComplex"
result = primitive.Integer(sub_name='result')
timestamp = primitive.DateTime(sub_name='timestamp')
shifts_list = Array(ShiftExtendedSoapModel, sub_name='shifts')
class HelloSwitchService(ServiceBase):
@srpc(Integer, _returns=Array(Integer))
def request_analysis(requester):
print "Got Request", requester
arr = DistributedDetector.requested_analysis(requester)
print arr
return arr
def test_self_referential_array_workaround(self):
from spyne.util.dictdoc import get_object_as_dict
class Category(ComplexModel):
id = Integer(min_occurs=1, max_occurs=1, nillable=False)
Category._type_info['children'] = Array(Category)
parent = Category()
parent.children = [Category(id=0), Category(id=1)]
d = get_object_as_dict(parent, Category)
pprint(d)
assert d['children'][0]['id'] == 0
assert d['children'][1]['id'] == 1
class SoapService(ServiceBase):
@rpc(_returns=Category)
def view_categories(ctx):
pass
Application([SoapService],
'service.soap',
in_protocol=ProtocolBase(),
out_protocol=ProtocolBase())
def test_array_customization(self):
CC = Array(Unicode).customize(
serializer_attrs=dict(min_len=5),
punks='roll',
)
assert CC.Attributes.punks == 'roll'
assert CC._type_info[0].Attributes.min_len == 5
class AddMessageService(ServiceBase):
"""
This service is used for creating a message.
"""
@srpc(Message, _returns=Array(Message))
def create_message(message):
"""
Create a message from the query parameters.
:param message: set as namespace in Soap11 request body.
:return: an array of Message object.
"""
msg = {
'title': message.title,
'content': message.content,
'sender': message.sender,
'url': message.url
}
messages.append(msg)
return messages
class InteropBare(ServiceBase):
@srpc(String, _returns=String, _body_style='bare')
def echo_simple_bare(ss):
return ss
@srpc(Array(String), _returns=Array(String), _body_style='bare')
def echo_complex_bare(ss):
return ss
@srpc(_returns=String, _body_style='bare')
def empty_input_bare():
return "empty"
@srpc(String, _body_style='bare')
def empty_output_bare(ss):
assert ss is not None
class EventTicketRequest(ComplexModel):
__namespace__ = 'spyne.ticketx.event'
event = Event
list_section = Array(EventSection)
callback = Unicode
callback_type = Unicode
class Guia(ComplexModel):
__namespace__ = NS
StrNumGui = String
DtEntrega = Date
StrCodUni = String
StrNomUni = String
StrEndUni = String
StrNumUni = String
StrBaiUni = String
StrCepUni = String
StrCidUni = String
StrEstUni = String
StrConUni = String
StrTelUni = String
alimentos = Array(Alimento)
def build_guia_obj(self, data, soliciacao):
guia_dict = {
'numero_guia': data.get('StrNumGui'),
'data_entrega': data.get('DtEntrega'),
'codigo_unidade': data.get('StrCodUni'),
'nome_unidade': data.get('StrNomUni'),
'endereco_unidade': data.get('StrEndUni'),
'numero_unidade': data.get('StrNumUni'),
'bairro_unidade': data.get('StrBaiUni'),
'cep_unidade': data.get('StrCepUni'),
'cidade_unidade': data.get('StrCidUni'),
'estado_unidade': data.get('StrEstUni'),
'contato_unidade': data.get('StrConUni'),
'telefone_unidade': data.get('StrTelUni'),
'solicitacao': soliciacao
}
return GuiaModel(**guia_dict)
def create_many(self, guias_data, solicitacao): # noqa C901
guias_obj_list = []
alimentos_dict_list = []
for data in guias_data:
alimentos_data = data.pop('alimentos', [])
guia_obj = self.build_guia_obj(data, solicitacao)
guias_obj_list.append(guia_obj)
for data in alimentos_data:
data['guia'] = guia_obj
alimentos_dict_list.append(data)
try:
GuiaModel.objects.bulk_create(guias_obj_list)
except IntegrityError as e:
if 'unique constraint' in str(e):
error = str(e)
msg = error.split('Key')
raise IntegrityError('Guia duplicada:' + msg[1])
raise IntegrityError('Erro ao salvar Guia.')
Alimento().create_many(alimentos_dict_list)
return guias_obj_list
def _process_item(v):
"""This function maps sqlalchemy types to spyne types."""
rpc_type = None
if isinstance(v, Column):
if isinstance(v.type, sqlalchemy.Enum):
if v.type.convert_unicode:
rpc_type = primitive.Unicode(values=v.type.enums)
else:
rpc_type = primitive.String(values=v.type.enums)
elif v.type in _type_map:
rpc_type = _type_map[v.type]
elif type(v.type) in _type_map:
rpc_type = _type_map[type(v.type)]
else:
raise Exception("soap_type was not found. maybe _type_map needs a "
"new entry. %r" % v)
elif isinstance(v, RelationshipProperty):
v.enable_typechecks = False
# FIXME: Distinguish between *ToMany and *ToOne relationship.
# rpc_type = v.argument
rpc_type = Array(v.argument)
return rpc_type
class SomeService(ServiceBase):
@srpc(_returns=Array(Permission))
def yay():
return [
Permission(application='app', feature='f1'),
Permission(application='app', feature='f2')
]
class SomeService(Service):
@rpc(String(max_occurs='unbounded'),
_returns=Array(KeyValuePair),
_in_variable_names={'keys': 'key'})
def get_values(ctx, keys):
for k in keys:
yield KeyValuePair(key=k, value=data[k])
class HelloWorldService(ServiceBase):
@srpc(_returns=Array(Permission))
def simple():
return v
@srpc(_returns=Permission.customize(max_occurs=float('inf')))
def complex():
return v
class User(ComplexModel):
__namespace__ = "user"
userid = Integer
username = String
firstname = String
lastname = String
permissions = Array(Permission)
class Allele(ComplexModel):
"""
Used in MutalyzerOutput data type.
"""
__namespace__ = SOAP_NAMESPACE
description = Mandatory.Unicode
allele = Array(RawVar)
class CheckSyntaxOutput(ComplexModel):
"""
Return type of SOAP method checkSyntax.
"""
__namespace__ = SOAP_NAMESPACE
valid = Mandatory.Boolean
messages = Array(SoapMessage)
def test_array_customization_complex(self):
class C(ComplexModel):
u = Unicode
CC = Array(C).customize(punks='roll',
serializer_attrs=dict(bidik=True))
assert CC.Attributes.punks == 'roll'
assert CC._type_info[0].Attributes.bidik == True
class ComplexRequestsResponseSoapModel(ComplexModel):
__namespace__ = NAMESPACE
__type_name__ = "requestsresponseComplex"
result = primitive.Integer(sub_name='result')
timestamp = primitive.DateTime(sub_name='timestamp')
requests_list = Array(SimpleOutsourcingRequestSoapModel,
sub_name='requests')
def test_serialize_complex_array(self):
days = [
DaysOfWeekEnum.Monday,
DaysOfWeekEnum.Tuesday,
DaysOfWeekEnum.Wednesday,
DaysOfWeekEnum.Thursday,
DaysOfWeekEnum.Friday,
DaysOfWeekEnum.Saturday,
DaysOfWeekEnum.Sunday,
]
days_xml = [
('{tns}DaysOfWeekEnum', 'Monday'),
('{tns}DaysOfWeekEnum', 'Tuesday'),
('{tns}DaysOfWeekEnum', 'Wednesday'),
('{tns}DaysOfWeekEnum', 'Thursday'),
('{tns}DaysOfWeekEnum', 'Friday'),
('{tns}DaysOfWeekEnum', 'Saturday'),
('{tns}DaysOfWeekEnum', 'Sunday'),
]
DaysOfWeekEnumArray = Array(DaysOfWeekEnum)
DaysOfWeekEnumArray.__namespace__ = 'tns'
elt = etree.Element('test')
XmlObject().to_parent_element(DaysOfWeekEnumArray, days,
'test_namespace', elt)
elt = elt[0]
ret = XmlObject().from_element(Array(DaysOfWeekEnum), elt)
assert days == ret
print((etree.tostring(elt, pretty_print=True)))
pprint(self.app.interface.nsmap)
assert days_xml == [ (e.tag, e.text) for e in
elt.xpath('//tns:DaysOfWeekEnum', namespaces=self.app.interface.nsmap)]
