def test_no_gc_collect(self):
class PingService(Service):
@srpc(_returns=Boolean)
def ping():
return True
application = Application([PingService],
'some_tns',
in_protocol=XmlDocument(),
out_protocol=XmlDocument())
server = NullServer(application)
origin_collect = gc.collect
origin_MIN_GC_INTERVAL = const.MIN_GC_INTERVAL
try:
gc.collect = lambda: 1 / 0
with self.assertRaises(ZeroDivisionError):
const.MIN_GC_INTERVAL = 0
server.service.ping()
# No raise
const.MIN_GC_INTERVAL = float('inf')
server.service.ping()
finally:
gc.collect = origin_collect
const.MIN_GC_INTERVAL = origin_MIN_GC_INTERVAL
def test_ostr(self):
queue = set()
class MessageService(Service):
@srpc(String, String, _returns=Array(String))
def send_message(s, k):
queue.add((s, k))
return [s, k]
application = Application([MessageService],
'some_tns',
in_protocol=XmlDocument(),
out_protocol=XmlDocument())
ostr_server = NullServer(application, ostr=True)
queue.clear()
ret = ostr_server.service.send_message("zabaaa", k="hobaa")
assert set([("zabaaa", "hobaa")]) == queue
assert etree.fromstring(b''.join(ret)).xpath(
'//tns:string/text()',
namespaces=application.interface.nsmap) == ['zabaaa', 'hobaa']
queue.clear()
ostr_server.service.send_message(k="hobaa")
assert set([(None, "hobaa")]) == queue
queue.clear()
ostr_server.service.send_message("zobaaa", s="hobaa")
assert set([("hobaa", None)]) == queue
def setup(self):
super(TestServicesSoap, self).setup()
self.server = NullServer(application, ostr=True)
# Unfortunately there's no easy way to just give a SUDS client a
# complete WSDL string, it only accepts a URL to it. So we create one.
self.wsdl = _write_wsdl(self.server)
self.client = Client('file://%s' % self.wsdl, cache=None)
def register_application(app):
key = (app.tns, app.name)
from spyne.server.null import NullServer
try:
import traceback
stack = traceback.format_stack()
except ImportError:
stack = None
prev = _applications.get(key, None)
if prev is not None:
if hash(prev.app) == hash(app):
logger.debug("Application %r previously registered as %r is the same"
" as %r. Skipping." % (prev.app, key, app))
prev.inst_stack.append(stack)
else:
logger.warning("Overwriting application %r(%r)." % (key, app))
if prev.inst_stack is not None:
stack_traces = []
for s in prev.inst_stack:
if s is not None:
stack_traces.append(''.join(s))
logger.debug("Stack trace of the instantiation:\n%s" %
'====================\n'.join(stack_traces))
_applications[key] = _ApplicationMetaData(app=app, inst_stack=[stack],
null=NullServer(app))
logger.debug("Registering %r as %r" % (app, key))
def client(connection_type, testdb_uri):
print("GETTING CLIENT")
if connection_type == 'local':
client = JSONConnection(app_name='Hydra Local Test Suite', db_url=testdb_uri)
#fake a login using the test's session
client.user_id = 1
client.connect()
else:
from spyne.server.null import NullServer
from hydra_server import initialize_api_server
hydra_server = initialize_api_server(testdb_uri, test=True)
null_server = NullServer(hydra_server.json_application, ostr=True)
#The url argument here is to avoid the connection complaining.
#It's not actually used, as we're using a null (testing) server
client = RemoteJSONConnection(url='localhost:8080/json',
app_name='Hydra Remote Test Suite',
test_server=null_server)
client.login('root', '')
client.testutils = hydra_base.util.testing.TestUtil(client)
pytest.root_user_id = 1
pytest.user_a = client.testutils.create_user("UserA")
pytest.user_b = client.testutils.create_user("UserB")
pytest.user_c = client.testutils.create_user("UserC", role='developer')
yield client
#???
hydra_base.db.close_session()
try:
drop_tables(testdb_uri)
except Exception as err:
print("Error dropping DB")
def test_remote_call_error(self):
from spyne import mrpc
v = 'deger'
class SomeComplexModel(ComplexModel):
@mrpc(_returns=SelfReference)
def put(self, ctx):
return v
class SomeService(ServiceBase):
@rpc(_returns=SomeComplexModel)
def get(ctx):
return SomeComplexModel()
null = NullServer(Application([SomeService], tns='some_tns'))
try:
null.service.put()
except ResourceNotFoundError:
pass
else:
raise Exception(
"Must fail with: \"Requested resource "
"'{spyne.test.model.test_complex}SomeComplexModel' not found\""
)
def test_wrapped_array_in_wrapped_response(self):
from spyne.model.complex import ComplexModel, Array
from spyne.model.primitive import Unicode
class Permission(ComplexModel):
_type_info = [
('application', Unicode),
('feature', Unicode),
]
class SomeService(ServiceBase):
@srpc(_returns=Array(Permission))
def yay():
return [
Permission(application='app', feature='f1'),
Permission(application='app', feature='f2')
]
app = Application([SomeService],
'tns',
in_protocol=JsonDocument(),
out_protocol=JsonDocument(ignore_wrappers=False))
server = NullServer(app, ostr=True)
retstr = ''.join(server.service.yay())
print(retstr)
assert retstr == '{"yayResponse": {"yayResult": [' \
'{"Permission": {"application": "app", "feature": "f1"}}, ' \
'{"Permission": {"application": "app", "feature": "f2"}}]}}'
def test_call(self):
queue = set()
class MessageService(Service):
@srpc(String, String)
def send_message(s, k):
queue.add((s, k))
application = Application([MessageService],
'some_tns',
in_protocol=XmlDocument(),
out_protocol=XmlDocument())
server = NullServer(application)
queue.clear()
server.service.send_message("zabaaa", k="hobaa")
assert set([("zabaaa", "hobaa")]) == queue
queue.clear()
server.service.send_message(k="hobaa")
assert set([(None, "hobaa")]) == queue
queue.clear()
server.service.send_message("zobaaa", s="hobaa")
assert set([("hobaa", None)]) == queue
def illustrate_wrappers(self):
from spyne.model.complex import ComplexModel, Array
from spyne.model.primitive import Unicode
class Permission(ComplexModel):
_type_info = [
('application', Unicode),
('feature', Unicode),
]
class SomeService(ServiceBase):
@srpc(_returns=Array(Permission))
def yay():
return [
Permission(application='app', feature='f1'),
Permission(application='app', feature='f2')
]
app = Application([SomeService],
'tns',
in_protocol=JsonDocument(),
out_protocol=JsonDocument(ignore_wrappers=False))
server = NullServer(app, ostr=True)
print ''.join(server.service.yay())
def test_call(self):
queue = set()
class MessageService(ServiceBase):
@srpc(String)
def send_message(s):
queue.add(s)
application = Application([MessageService], 'some_tns',
interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11())
server = NullServer(application)
server.service.send_message("zabaaa")
assert set(["zabaaa"]) == queue
def test_callback_name(self):
callback_name = 'some_callback'
retval = 42
class SomeService(ServiceBase):
@srpc(_returns=Integer)
def yay():
return retval
app = Application([SomeService],
'tns',
in_protocol=JsonDocument(),
out_protocol=JsonP(callback_name))
server = NullServer(app, ostr=True)
assert ''.join(
server.service.yay()) == '%s(%d);' % (callback_name, retval)
def test_call_one_arg(self):
queue = set()
class MessageService(Service):
@srpc(String)
def send_message(s):
queue.add(s)
application = Application([MessageService],
'some_tns',
in_protocol=XmlDocument(),
out_protocol=XmlDocument())
server = NullServer(application)
server.service.send_message("zabaaa")
assert set(["zabaaa"]) == queue
def test_remote_call_success(self):
from spyne import mrpc
class SomeComplexModel(ComplexModel):
i = Integer
@mrpc(_returns=SelfReference)
def echo(self, ctx):
return self
class SomeService(ServiceBase):
@rpc(_returns=SomeComplexModel)
def get(ctx):
return SomeComplexModel()
null = NullServer(Application([SomeService], tns='some_tns'))
v = SomeComplexModel(i=5)
assert null.service.echo(v) is v
def test_callback_name(self):
callback_name = 'some_callback'
retval = 42
class SomeService(ServiceBase):
@srpc(_returns=Integer)
def yay():
return retval
app = Application([SomeService], 'tns',
in_protocol=JsonDocument(),
out_protocol=JsonP(callback_name))
server = NullServer(app, ostr=True)
ret = server.service.yay()
ret = list(ret)
print(ret)
assert b''.join(ret) == b''.join((callback_name.encode('utf8'), b'(',
str(retval).encode('utf8'), b');'))
def test_simple_aux_nullserver(self):
data = []
class Service(ServiceBase):
@srpc(String)
def call(s):
data.append(s)
class AuxService(ServiceBase):
__aux__ = SyncAuxProc()
@srpc(String)
def call(s):
data.append(s)
app = Application([Service, AuxService], 'tns','name', Soap11(), Soap11())
server = NullServer(app)
server.service.call("hey")
assert data == ['hey', 'hey']
def test_callback_name(self):
callback_name = 'some_callback'
class SomeComplexModel(ComplexModel):
i = Integer
s = Unicode
v1 = 42
v2 = SomeComplexModel(i=42, s='foo')
class SomeService(ServiceBase):
@srpc(_returns=Integer)
def yay():
return v1
@srpc(_returns=SomeComplexModel)
def complex():
return v2
app = Application([SomeService],
'tns',
in_protocol=JsonDocument(),
out_protocol=JsonP(callback_name))
server = NullServer(app, ostr=True)
ret = server.service.yay()
ret = list(ret)
print(b''.join(ret))
assert b''.join(ret) == b''.join((callback_name.encode('utf8'), b'(',
str(v1).encode('utf8'), b');'))
ret = server.service.complex()
ret = list(ret)
print(b''.join(ret))
assert b''.join(ret) == b''.join((callback_name.encode('utf8'), b'(',
json.dumps({
"i": 42,
"s": "foo"
}), b');'))
if __name__ == '__main__':
import logging
from pprint import pprint
logging.basicConfig(level=logging.INFO)
# mutes context markers. set logging level to logging.INFO to enable
# them.
logging.getLogger('spyne.server.null').setLevel(logging.CRITICAL)
print("With serialization")
print("==================")
print()
null = NullServer(application, ostr=True)
ret_stream = null.service.say_hello('Dave', 5)
ret_string = ''.join(ret_stream)
print(ret_string)
print()
print("Without serialization")
print("=====================")
print()
null = NullServer(application, ostr=False)
ret = null.service.say_hello('Dave', 5)
# because the return value is a generator, we need to iterate over it to
# see the actual return values.
pprint(list(ret))
def server():
return NullServer(application, ostr=True)
class SomeService(ServiceBase):
@rpc()
def server_exception(ctx):
raise Exception("boo!")
@rpc()
def server_fault(ctx):
raise Fault("Server", "boo and you know it!")
@rpc()
def client_fault(ctx):
raise Fault("Client", "zzzz...")
server = NullServer(Application([SomeService], 'spyne.examples.logging'))
if __name__ == "__main__":
import logging
logging.basicConfig(level=logging.DEBUG)
logging.info(G("all fault tracebacks are logged"))
logging.getLogger('spyne.application').setLevel(logging.DEBUG)
try:
server.service.server_exception()
except:
pass
try:
server.service.server_fault()
except:
def setup(self):
super(TestServicesJson, self).setup()
self.server = NullServer(application, ostr=True)
