def test_simple(self):
class SomeService(ServiceBase):
@srpc(String, _returns=String)
def some_call(s):
return s
app = Application([SomeService], 'tns',
in_protocol=HttpRpc(hier_delim='_'),
out_protocol=HtmlMicroFormat())
server = WsgiApplication(app)
initial_ctx = WsgiMethodContext(server, {
'QUERY_STRING': 's=s',
'PATH_INFO': '/some_call',
'REQUEST_METHOD': 'GET',
'SERVER_NAME': 'localhost',
}, 'some-content-type')
ctx, = server.generate_contexts(initial_ctx)
assert ctx.in_error is None
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
assert ''.join(ctx.out_string) == '<div class="some_callResponse"><div class="some_callResult">s</div></div>'
def test_multiple_return(self):
class SomeNotSoComplexModel(ComplexModel):
s = String
class SomeService(ServiceBase):
@srpc(_returns=[Integer, String])
def some_call():
return 1, 's'
app = Application([SomeService], 'tns', in_protocol=HttpRpc(), out_protocol=HtmlMicroFormat())
server = WsgiApplication(app)
initial_ctx = WsgiMethodContext(server, {
'QUERY_STRING': '',
'PATH_INFO': '/some_call',
'REQUEST_METHOD': 'GET',
'SERVER_NAME': 'localhost',
}, 'some-content-type')
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
assert ''.join(ctx.out_string) == '<div class="some_callResponse"><div class="some_callResult0">1</div><div class="some_callResult1">s</div></div>'
def _test(services, qs, validator='soft'):
app = Application(services,
'tns',
in_protocol=HttpRpc(validator=validator),
out_protocol=HttpRpc())
server = WsgiApplication(app)
initial_ctx = WsgiMethodContext(
server, {
'QUERY_STRING': qs,
'PATH_INFO': '/some_call',
'REQUEST_METHOD': 'GET',
'SERVER_NAME': "localhost",
}, 'some-content-type')
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
if ctx.in_error is not None:
raise ctx.in_error
server.get_out_object(ctx)
if ctx.out_error is not None:
raise ctx.out_error
server.get_out_string(ctx)
return ctx
def _handle_tr069_message(
cls,
ctx: WsgiMethodContext,
message: ComplexModelBase,
) -> ComplexModelBase:
# Log incoming msg
logger.debug('Handling TR069 message: %s %s',
message.__class__.__name__, str(as_dict(message)))
req = cls._get_tr069_response_from_sm(ctx, message)
# Log outgoing msg
logger.debug('Sending TR069 message: %s %s', req.__class__.__name__,
str(as_dict(req)))
# Set header
ctx.out_header = models.ID(mustUnderstand='1')
ctx.out_header.Data = 'null'
# Set return message name
if isinstance(req, models.DummyInput):
# Generate 'empty' request to CPE using empty message name
ctx.descriptor.out_message.Attributes.sub_name = 'EmptyHttp'
return models.AcsToCpeRequests()
ctx.descriptor.out_message.Attributes.sub_name = req.__class__.__name__
return cls._generate_acs_to_cpe_request_copy(req)
def _handle_tr069_message(
cls,
ctx: WsgiMethodContext,
message: ComplexModelBase,
) -> ComplexModelBase:
# Log incoming msg
if hasattr(message, 'as_dict'):
logging.debug('Handling TR069 message: %s', str(type(message)))
else:
logging.debug('Handling TR069 message.')
# The manager will route the request to the state machine handling
# the specific eNodeB.
req = cls.state_machine_manager.handle_tr069_message(ctx, message)
# Log outgoing msg
if hasattr(req, 'as_dict'):
logging.debug('Sending TR069 message: %s', str(req.as_dict()))
else:
logging.debug('Sending TR069 message.')
# Set header
ctx.out_header = models.ID(mustUnderstand='1')
ctx.out_header.Data = 'null'
# Set return message name
if isinstance(req, models.DummyInput):
# Generate 'empty' request to CPE using empty message name
ctx.descriptor.out_message.Attributes.sub_name = 'EmptyHttp'
return models.AcsToCpeRequests()
ctx.descriptor.out_message.Attributes.sub_name = req.__class__.__name__
return cls._generate_acs_to_cpe_request_copy(req)
def test_multiple(self):
class SomeService(ServiceBase):
@srpc(String(max_occurs='unbounded'), _returns=String)
def some_call(s):
print(s)
return '\n'.join(s)
app = Application([SomeService], 'tns',
in_protocol=HttpRpc(hier_delim='_'),
out_protocol=HtmlMicroFormat())
server = WsgiApplication(app)
initial_ctx = WsgiMethodContext(server, {
'QUERY_STRING': 's=1&s=2',
'PATH_INFO': '/some_call',
'REQUEST_METHOD': 'GET',
'SERVER_NAME': 'localhost',
}, 'some-content-type')
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
assert b''.join(ctx.out_string) == (b'<div class="some_callResponse">'
b'<div class="some_callResult">1\n2</div></div>')
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
assert b''.join(ctx.out_string) == b'<div class="some_callResponse">' \
b'<div class="some_callResult">1\n2</div></div>'
def __get_ctx(self, mn, qs):
server = WsgiApplication(self.application)
ctx = WsgiMethodContext(
server, {
'QUERY_STRING': qs,
'PATH_INFO': '/%s' % mn,
'REQUEST_METHOD': "GET",
'SERVER_NAME': 'localhost',
}, 'some-content-type')
ctx, = server.generate_contexts(ctx)
server.get_in_object(ctx)
return ctx
def test_rules(self):
_int = 5
_fragment = 'some_fragment'
class SomeService(ServiceBase):
@srpc(Integer,
_returns=Integer,
_patterns=[HttpPattern('/%s/<some_int>' % _fragment)])
def some_call(some_int):
assert some_int == _int
app = Application([SomeService],
'tns',
in_protocol=HttpRpc(),
out_protocol=HttpRpc())
server = WsgiApplication(app)
environ = {
'QUERY_STRING': '',
'PATH_INFO': '/%s/%d' % (_fragment, _int),
'SERVER_PATH': "/",
'SERVER_NAME': "localhost",
'wsgi.url_scheme': 'http',
'SERVER_PORT': '9000',
'REQUEST_METHOD': 'GET',
}
initial_ctx = WsgiMethodContext(server, environ, 'some-content-type')
ctx, = server.generate_contexts(initial_ctx)
foo = []
for i in server._http_patterns.iter_rules():
foo.append(i)
assert len(foo) == 1
print foo
assert ctx.descriptor is not None
server.get_in_object(ctx)
assert ctx.in_error is None
server.get_out_object(ctx)
assert ctx.out_error is None
def test_complex(self):
class CM(ComplexModel):
i = Integer
s = String
class CCM(ComplexModel):
c = CM
i = Integer
s = String
class SomeService(ServiceBase):
@srpc(CCM, _returns=CCM)
def some_call(ccm):
return CCM(c=ccm.c,i=ccm.i, s=ccm.s)
app = Application([SomeService], 'tns',
in_protocol=HttpRpc(hier_delim='_'),
out_protocol=HtmlMicroFormat())
server = WsgiApplication(app)
initial_ctx = WsgiMethodContext(server, {
'QUERY_STRING': 'ccm_c_s=abc&ccm_c_i=123&ccm_i=456&ccm_s=def',
'PATH_INFO': '/some_call',
'REQUEST_METHOD': 'GET',
'SERVER_NAME': 'localhost',
}, 'some-content-type')
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
#
# Here's what this is supposed to return:
#
# <div class="some_callResponse">
# <div class="some_callResult">
# <div class="i">456</div>
# <div class="c">
# <div class="i">123</div>
# <div class="s">abc</div>
# </div>
# <div class="s">def</div>
# </div>
# </div>
#
elt = html.fromstring(''.join(ctx.out_string))
print(html.tostring(elt, pretty_print=True))
resp = elt.find_class('some_callResponse')
assert len(resp) == 1
res = resp[0].find_class('some_callResult')
assert len(res) == 1
i = res[0].findall('div[@class="i"]')
assert len(i) == 1
assert i[0].text == '456'
c = res[0].findall('div[@class="c"]')
assert len(c) == 1
c_i = c[0].findall('div[@class="i"]')
assert len(c_i) == 1
assert c_i[0].text == '123'
c_s = c[0].findall('div[@class="s"]')
assert len(c_s) == 1
assert c_s[0].text == 'abc'
s = res[0].findall('div[@class="s"]')
assert len(s) == 1
assert s[0].text == 'def'
def test_rpc(self):
import sqlalchemy
from sqlalchemy import sql
class KeyValuePair(TableModel, self.DeclarativeBase):
__tablename__ = 'key_value_store'
__namespace__ = 'punk'
key = Column(sqlalchemy.String(100),
nullable=False,
primary_key=True)
value = Column(sqlalchemy.String, nullable=False)
self.metadata.create_all(self.engine)
import hashlib
session = self.Session()
for i in range(1, 10):
key = str(i)
m = hashlib.md5()
m.update(key)
value = m.hexdigest()
session.add(KeyValuePair(key=key, value=value))
session.commit()
from spyne.service import ServiceBase
from spyne.model.complex import Array
from spyne.model.primitive import String
class Service(ServiceBase):
@rpc(String(max_occurs='unbounded'),
_returns=Array(KeyValuePair),
_in_variable_names={'keys': 'key'})
def get_values(ctx, keys):
session = self.Session()
return session.query(KeyValuePair).filter(
sql.and_(KeyValuePair.key.in_(keys))).order_by(
KeyValuePair.key)
application = Application([Service],
in_protocol=HttpRpc(),
out_protocol=Soap11(),
name='Service',
tns='tns')
server = WsgiApplication(application)
initial_ctx = WsgiMethodContext(
server, {
'REQUEST_METHOD': 'GET',
'QUERY_STRING': 'key=1&key=2&key=3',
'PATH_INFO': '/get_values',
'SERVER_NAME': 'localhost',
}, 'some-content-type')
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
i = 0
for e in ctx.out_document[0][0][0]:
i += 1
key = str(i)
m = hashlib.md5()
m.update(key)
value = m.hexdigest()
_key = e.find('{%s}key' % KeyValuePair.get_namespace())
_value = e.find('{%s}value' % KeyValuePair.get_namespace())
print((_key, _key.text))
print((_value, _value.text))
self.assertEquals(_key.text, key)
self.assertEquals(_value.text, value)
