def test_can_specify_additional_custom_message(self):
try:
assert_not_raises(Exception, self._fail_with(ValueError), message='Foo')
except AssertionError as e:
assert_equals('unexpected exception ValueError(): Foo', exception_message(e))
else:
self.fail('test did not catch exception!')
def test_append_restriction(self):
l = xsd.ListElement(xsd.String, maxOccurs=1,
tagname='toto').empty_value()
l.append('a')
e = assert_raises(ValueError, lambda: l.append('a'))
assert_equals('You must not add more than 1 items to this list.',
str(e))
def test_supports_very_distant_dates(self):
raise SkipTest('XSDDate can currently only represent the value range of datetime.date')
future = XSDDate(12345, 4, 21)
assert_equals(12345, future.year)
past = XSDDate(-12345, 4, 21)
assert_equals(-12345, past.year)
def test_fails_with_sensible_default_error_message(self):
try:
assert_not_raises(Exception, self._fail_with(ValueError))
except AssertionError as e:
assert_equals('unexpected exception ValueError()', exception_message(e))
else:
self.fail('test did not catch exception!')
def test_parsing(self):
self.assert_parse(None, None)
self.assert_parse(None, 'nil')
parsed_time = self._parse('23:59:59+01:00')
assert_equals(time(23, 59, 59, tzinfo=FixedOffset(1, 0, '+01:00')), parsed_time)
parsed_time = self._parse('23:59:59-02:30')
assert_equals(time(23, 59, 59, tzinfo=FixedOffset(-2, -30, '-02:30')), parsed_time)
def test_can_generate_code_with_xsd_refs_to_elements_with_anoynmous_complex_types(self):
# The final test should have an object graph representation of the
# schema below. Currently I don't know how to represent multiple
# xs:elements in a schema without using ComplexTypes.
# Maybe we should have a special type like AnonymousComplexType and
# put that directly into schema.elements?
xml = utils.open_document('tests/assets/generation/reference_complex.xsd')
schema = xsdspec.Schema.parse_xmlelement(etree.fromstring(xml))
code = xsd2py.schema_to_py(schema, ['xs'])
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(3, symbols)
assert_contains('Person', symbols.keys())
assert_contains('Job', symbols.keys())
assert_equals(set(['person', 'job']), list(schemas[0].elements))
Job = symbols['Job']
Person = symbols['Person']
person_ref = Job.person
assert_isinstance(person_ref, xsd.Ref)
assert_equals(person_ref._type, Person)
job = Job()
person = Person()
person.name = 'Foo'
job.person = person
def test_can_generate_code_with_xsd_refs_to_simple_elements(self):
xml = utils.open_document(
'tests/assets/generation/reference_simple.xsd')
code = xsd2py.generate_code_from_xsd(xml)
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
# somehow we need to be able to have schemas with multiple possible
# root elements
assert_length(3, symbols)
assert_contains('Name', symbols.keys())
assert_contains('Job', symbols.keys())
assert_equals(set(['name', 'job']), list(schemas[0].elements))
Job = symbols['Job']
Name = symbols['Name']
name_ref = Job.name
# not sure if these assertions are correct but they should give you
# the idea
assert_isinstance(name_ref, xsd.Ref)
assert_equals(name_ref._type, Name)
job = Job()
# Should not raise
job.name = u'Foo'
def test_can_generate_code_with_xsd_refs_to_elements_with_anoynmous_complex_types(
self):
# The final test should have an object graph representation of the
# schema below. Currently I don't know how to represent multiple
# xs:elements in a schema without using ComplexTypes.
# Maybe we should have a special type like AnonymousComplexType and
# put that directly into schema.elements?
xml = utils.open_document(
'tests/assets/generation/reference_complex.xsd')
schema = xsdspec.Schema.parse_xmlelement(etree.fromstring(xml))
code = xsd2py.schema_to_py(schema, ['xs'])
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(3, symbols)
assert_contains('Person', symbols.keys())
assert_contains('Job', symbols.keys())
assert_equals(set(['person', 'job']), list(schemas[0].elements))
Job = symbols['Job']
Person = symbols['Person']
person_ref = Job.person
assert_isinstance(person_ref, xsd.Ref)
assert_equals(person_ref._type, Person)
job = Job()
person = Person()
person.name = 'Foo'
job.person = person
def test_can_generate_code_with_xsd_refs_to_simple_elements(self):
xml = utils.open_document('tests/assets/generation/reference_simple.xsd')
code = xsd2py.generate_code_from_xsd(xml)
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
# somehow we need to be able to have schemas with multiple possible
# root elements
assert_length(3, symbols)
assert_contains('Name', symbols.keys())
assert_contains('Job', symbols.keys())
assert_equals(set(['name', 'job']), list(schemas[0].elements))
Job = symbols['Job']
Name = symbols['Name']
name_ref = Job.name
# not sure if these assertions are correct but they should give you
# the idea
assert_isinstance(name_ref, xsd.Ref)
assert_equals(name_ref._type, Name)
job = Job()
# Should not raise
job.name = u'Foo'
def test_can_dispatch_good_soap_message(self):
handler, handler_state = echo_handler()
dispatcher = SOAPDispatcher(echo_service(handler))
soap_message = (
'<ns1:echoRequest xmlns:ns1="http://soap.example/echo/types">'
'<value>foobar</value>'
'</ns1:echoRequest>')
request_message = self._wrap_with_soap_envelope(soap_message)
request = SOAPRequest(dict(SOAPACTION='echo', REQUEST_METHOD='POST'),
request_message)
response = dispatcher.dispatch(request)
self.assert_is_successful_response(response, handler_state)
assert_equals('foobar', handler_state.input_.value)
response_document = etree.fromstring(response.http_content)
response_xml = etree.tostring(response_document, pretty_print=True)
expected_xml = (
b'<ns0:Envelope xmlns:ns0="http://schemas.xmlsoap.org/soap/envelope/">\n'
b' <ns0:Body>\n'
b' <ns0:echoResponse xmlns:ns0="http://soap.example/echo/types">\n'
b' <value>foobar</value>\n'
b' </ns0:echoResponse>\n'
b' </ns0:Body>\n'
b'</ns0:Envelope>\n')
assert_equals(expected_xml, response_xml)
def test_can_include_imported_schemas_during_validation(self):
# In case the SOAPDispatcher would not use imported schemas for
# validation it would fail because the 'code' tag is only defined in
# the imported schema
handler, handler_state = echo_handler()
service = echo_service(handler)
class CodeType(xsd.String):
pattern = r'[0-9]{5}'
class Container(xsd.ComplexType):
value = xsd.Element(CodeType)
code_schema = xsd.Schema(
'http://soap.example/included',
location='http://soap.example/included',
elementFormDefault=xsd.ElementFormDefault.UNQUALIFIED,
simpleTypes=[CodeType],
complexTypes=[Container],
elements={'foo': xsd.Element(Container)},
)
service.methods[0].input = 'foo'
service.schemas[0].imports = [code_schema]
# The setup is a bit simplistic because the <code> tag is not parsed
# into a soapfish model element for the handler but this was enough
# to trigger the bug
dispatcher = SOAPDispatcher(service)
wsgi_environ = dict(SOAPACTION='echo', REQUEST_METHOD='POST')
soap_message = '<ns0:foo xmlns:ns0="http://soap.example/included"><value>12345</value></ns0:foo>'
request = SOAPRequest(wsgi_environ,
self._wrap_with_soap_envelope(soap_message))
response = dispatcher.dispatch(request)
self.assert_is_successful_response(response, handler_state)
assert_equals('12345', handler_state.input_.value)
def test_can_render_simple_element(self):
element = xsdspec.Element()
element.name = 'Name'
element.type = 'xs:string'
expected_xml = b'<element name="Name" type="xs:string"/>\n'
assert_equals(expected_xml, element.xml('element'))
def test_can_specify_additional_custom_message(self):
e = self.assert_fail({'foo': '42'}, {}, message='Bar')
assert_equals("%r not in {}: Bar" % 'foo', exception_message(e))
e = self.assert_fail({'foo': 21}, {'foo': 42}, message='Bar')
expected_error = "%r=21 != %r=42: Bar" % ('foo', 'foo')
assert_equals(expected_error, exception_message(e))
def test_fails_with_sensible_default_error_message(self):
e = self.assert_fail({'foo': '42'}, {})
assert_equals("%r not in {}" % 'foo', exception_message(e))
e = self.assert_fail({'foo': 21}, {'foo': 42})
expected_error = "%r=21 != %r=42" % ('foo', 'foo')
assert_equals(expected_error, exception_message(e))
def test_can_render_simple_element(self):
element = xsdspec.Element()
element.name = 'Name'
element.type = 'xs:string'
expected_xml = b'<element name="Name" type="xs:string"/>\n'
assert_equals(expected_xml, element.xml('element'))
def test_parsing(self):
self.assert_parse(None, None)
self.assert_parse(None, 'nil')
parsed_time = self._parse('23:59:59+01:00')
assert_equals(time(23, 59, 59, tzinfo=iso8601.FixedOffset(1, 0, '+01:00')), parsed_time)
parsed_time = self._parse('23:59:59-02:30')
assert_equals(time(23, 59, 59, tzinfo=iso8601.FixedOffset(-2, -30, '-02:30')), parsed_time)
def test_can_dispatch_good_soap_message(self):
handler, handler_state = echo_handler()
dispatcher = SOAPDispatcher(echo_service(handler))
soap_message = (
'<ns1:echoRequest xmlns:ns1="http://soap.example/echo/types">'
'<value>foobar</value>'
'</ns1:echoRequest>'
)
request_message = self._wrap_with_soap_envelope(soap_message)
request = SOAPRequest(dict(SOAPACTION='echo', REQUEST_METHOD='POST'), request_message)
response = dispatcher.dispatch(request)
self.assert_is_successful_response(response, handler_state)
assert_equals('foobar', handler_state.input_.value)
response_document = etree.fromstring(response.http_content)
response_xml = etree.tostring(response_document, pretty_print=True)
expected_xml = (
b'<ns0:Envelope xmlns:ns0="http://schemas.xmlsoap.org/soap/envelope/">\n'
b' <ns0:Body>\n'
b' <ns0:echoResponse xmlns:ns0="http://soap.example/echo/types">\n'
b' <value>foobar</value>\n'
b' </ns0:echoResponse>\n'
b' </ns0:Body>\n'
b'</ns0:Envelope>\n'
)
assert_equals(expected_xml, response_xml)
def test_can_reject_malformed_xml_soap_message(self):
request = SOAPRequest(dict(SOAPACTION='echo', REQUEST_METHOD='POST'), 'garbage')
dispatcher = SOAPDispatcher(echo_service())
response = dispatcher.dispatch(request)
assert_equals(500, response.http_status_code)
assert_equals('text/xml', response.http_headers['Content-Type'])
self.assert_is_soap_fault(response, partial_fault_string=u"Start tag expected, '<' not found")
def test_can_include_imported_schemas_during_validation(self):
# In case the SOAPDispatcher would not use imported schemas for
# validation it would fail because the 'code' tag is only defined in
# the imported schema
handler, handler_state = echo_handler()
service = echo_service(handler)
class CodeType(xsd.String):
pattern = r'[0-9]{5}'
class Container(xsd.ComplexType):
value = xsd.Element(CodeType)
code_schema = xsd.Schema('http://soap.example/included',
location='http://soap.example/included',
elementFormDefault=xsd.ElementFormDefault.UNQUALIFIED,
simpleTypes=[CodeType],
complexTypes=[Container],
elements={'foo': xsd.Element(Container)},
)
service.methods[0].input = 'foo'
service.schemas[0].imports = [code_schema]
# The setup is a bit simplistic because the <code> tag is not parsed
# into a soapfish model element for the handler but this was enough
# to trigger the bug
dispatcher = SOAPDispatcher(service)
wsgi_environ = dict(SOAPACTION='echo', REQUEST_METHOD='POST')
soap_message = '<ns0:foo xmlns:ns0="http://soap.example/included"><value>12345</value></ns0:foo>'
request = SOAPRequest(wsgi_environ, self._wrap_with_soap_envelope(soap_message))
response = dispatcher.dispatch(request)
self.assert_is_successful_response(response, handler_state)
assert_equals('12345', handler_state.input_.value)
def test_rendering_timezones(self):
time_ = time(10,
15,
20,
tzinfo=iso8601.FixedOffset(1, 15, 'dummy zone'))
rendered_xml = self.xsd_type().xmlvalue(time_)
assert_equals('10:15:20+01:15', rendered_xml)
def test_can_generate_extension_of_type_with_special_chars(self):
xml = utils.open_document(
'tests/assets/generation/extension_with_special_chars.xsd')
code = xsd2py.generate_code_from_xsd(xml)
schemas, symbols = generated_symbols(code)
assert_true('BaseType_with_special_chars_123' in symbols)
assert_equals('BaseType_with_special_chars_123',
symbols['ComplexType'].__base__.__name__)
def test_accepts_plain_strings_even_if_subclassed(self):
class StringWithPattern(xsd.String):
pattern = r'[0-9]{3}'
self.xsd_type = StringWithPattern
stored = self.assert_can_set('123')
assert_equals('123', stored)
self.assert_can_not_set('abc')
self.assert_can_not_set('1234')
def test_can_generate_code_for_two_schemas(self):
xml = utils.open_document("tests/assets/generation/multi_schema.wsdl")
code = wsdl2py.generate_code_from_wsdl(xml, "client")
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(4, symbols)
assert_equals(["A"], list(schemas[0].elements))
assert_equals(["B"], list(schemas[1].elements))
def test_fails_with_sensible_default_error_message(self):
try:
assert_not_raises(Exception, self._fail_with(ValueError))
except AssertionError as e:
assert_equals('unexpected exception ValueError()',
exception_message(e))
else:
self.fail('test did not catch exception!')
def test_can_generate_code_for_two_schemas(self):
xml = utils.open_document('tests/assets/generation/multi_schema.wsdl')
code = wsdl2py.generate_code_from_wsdl(xml, 'client')
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(2, [s for s in symbols if s.startswith('Schema_')])
assert_equals(['A'], list(schemas[0].elements))
assert_equals(['B'], list(schemas[1].elements))
def test_parsing_timezone(self):
class Test(xsd.ComplexType):
time_ = xsd.Element(self.xsd_type, tagname='time')
parsed = Test.parsexml('<root><time>20:19:00+01:00</time></root>')
assert_equals(
time(20, 19, 0, tzinfo=iso8601.FixedOffset(1, 0, '+01:00')),
parsed.time_)
def test_can_omit_optional_attributes(self):
instance = self.SampleType(name='someName')
element = etree.Element('sample')
instance.render(element, instance)
assert_equals('someName', element.get('name'))
assert_none(element.get('value'))
assert_none(element.get('type'))
def test_can_generate_code_for_two_schemas(self):
xml = utils.open_document('tests/assets/generation/multi_schema.wsdl')
code = wsdl2py.generate_code_from_wsdl(xml, 'client')
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(2, [s for s in symbols if s.startswith('Schema_')])
assert_equals(['A'], list(schemas[0].elements))
assert_equals(['B'], list(schemas[1].elements))
def test_relative_paths(self):
path = 'tests/assets/relative/relative.wsdl'
xml = utils.open_document(path)
code = wsdl2py.generate_code_from_wsdl(xml, 'server', cwd=os.path.dirname(path))
if six.PY3:
code = code.decode()
assert_contains('Schema2_Element', code)
assert_contains('Schema3_Element', code)
assert_equals(1, code.count('Schema3_Element'))
def test_can_generate_code_for_inheritance(self):
xml = utils.open_document('tests/assets/generation/inheritance.wsdl')
code = wsdl2py.generate_code_from_wsdl(xml, 'client')
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(4, symbols)
assert_equals(['B', 'A'], list(schemas[0].elements))
assert_isinstance(schemas[0].elements['B']._type, xsd.String)
assert_isinstance(schemas[0].elements['A']._type, schemas[0].elements['B']._type.__class__)
def test_supports_very_distant_dates(self):
raise SkipTest(
'XSDDate can currently only represent the value range of datetime.date'
)
future = XSDDate(12345, 4, 21)
assert_equals(12345, future.year)
past = XSDDate(-12345, 4, 21)
assert_equals(-12345, past.year)
def test_can_generate_code_for_inheritance(self):
xml = utils.open_document('tests/assets/generation/inheritance.wsdl')
code = wsdl2py.generate_code_from_wsdl(xml, 'client')
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(4, symbols)
assert_equals(['B', 'A'], list(schemas[0].elements))
assert_isinstance(schemas[0].elements['B']._type, xsd.String)
assert_isinstance(schemas[0].elements['A']._type, schemas[0].elements['B']._type.__class__)
def test_accepts_plain_strings_even_if_subclassed(self):
class StringWithPattern(xsd.String):
pattern = r'[0-9]{3}'
self.xsd_type = StringWithPattern
stored = self.assert_can_set('123')
assert_equals('123', stored)
self.assert_can_not_set('abc')
self.assert_can_not_set('1234')
def test_can_reject_non_soap_xml_body(self):
request = SOAPRequest(dict(SOAPACTION='echo', REQUEST_METHOD='POST'), '<some>xml</some>')
dispatcher = SOAPDispatcher(echo_service())
# previously this raised an AttributeError due to an unhandled exception
response = dispatcher.dispatch(request)
assert_equals(500, response.http_status_code)
assert_equals('text/xml', response.http_headers['Content-Type'])
self.assert_is_soap_fault(response, partial_fault_string=u'Missing SOAP body')
def test_can_omit_optional_attributes(self):
with testutil.import_code(self.code) as generated:
instance = generated.SampleType(sampleAttrs=generated.SampleAttrs(name='someName'))
element = etree.Element('sample')
instance.render(element, instance)
assert_equals('someName', element.get('name'))
assert_none(element.get('value'))
assert_none(element.get('type'))
def test_can_reject_malformed_xml_soap_message(self):
request = SOAPRequest(dict(SOAPACTION='echo', REQUEST_METHOD='POST'),
'garbage')
dispatcher = SOAPDispatcher(echo_service())
response = dispatcher.dispatch(request)
assert_equals(500, response.http_status_code)
assert_equals('text/xml', response.http_headers['Content-Type'])
self.assert_is_soap_fault(
response,
partial_fault_string=u"Start tag expected, '<' not found")
def test_can_specify_additional_custom_message(self):
try:
assert_not_raises(Exception,
self._fail_with(ValueError),
message='Foo')
except AssertionError as e:
assert_equals('unexpected exception ValueError(): Foo',
exception_message(e))
else:
self.fail('test did not catch exception!')
def test_can_reject_non_soap_xml_body(self):
request = SOAPRequest(dict(SOAPACTION='echo', REQUEST_METHOD='POST'),
'<some>xml</some>')
dispatcher = SOAPDispatcher(echo_service())
# previously this raised an AttributeError due to an unhandled exception
response = dispatcher.dispatch(request)
assert_equals(500, response.http_status_code)
assert_equals('text/xml', response.http_headers['Content-Type'])
self.assert_is_soap_fault(response,
partial_fault_string=u'Missing SOAP body')
def test_can_generate_code_for_simple_element(self):
xml = utils.open_document('tests/assets/generation/simple_element.xsd')
code = xsd2py.generate_code_from_xsd(xml)
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(1, symbols)
assert_equals(['simpleElement'], list(schemas[0].elements))
simple_element = schemas[0].elements['simpleElement']
assert_isinstance(simple_element._type, xsd.String)
def test_can_generate_code_for_simple_element(self):
xml = utils.open_document('tests/assets/generation/simple_element.xsd')
code = xsd2py.generate_code_from_xsd(xml)
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(1, symbols)
assert_equals(['simpleElement'], list(schemas[0].elements))
simple_element = schemas[0].elements['simpleElement']
assert_isinstance(simple_element._type, xsd.String)
def test_can_generate_list_enumeration(self):
xml = utils.open_document('tests/assets/generation/enumeration.xsd')
code = xsd2py.generate_code_from_xsd(xml)
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(2, symbols)
assert_true(issubclass(symbols['MyList'], xsd.List))
my_list = symbols['MyList']()
assert_equals(my_list.accept(['B']), True)
def _check_reparse_wsdl(self, base, target):
tree = py2wsdl.generate_wsdl(base['PutOpsPort_SERVICE'])
xml = etree.tostring(tree, pretty_print=True)
code = wsdl2py.generate_code_from_wsdl(xml, target)
m = {}
self._exec(code, m)
# XXX too much autonaming magic
m['PutOpsPort_SERVICE'] = m.pop('PutOpsPortPort_SERVICE')
if target == 'client':
m['PutOpsPortServiceStub'] = m.pop('PutOpsPortPortServiceStub')
assert_equals(sorted(m), sorted(base))
def test_can_generate_list_enumeration(self):
xml = utils.open_document('tests/assets/generation/enumeration.xsd')
code = xsd2py.generate_code_from_xsd(xml)
schemas, symbols = generated_symbols(code)
assert_is_not_empty(schemas)
assert_length(2, symbols)
assert_true(issubclass(symbols['MyList'], xsd.List))
my_list = symbols['MyList']()
assert_equals(my_list.accept(['B']), True)
def _check_reparse_wsdl(self, base, target):
tree = py2wsdl.generate_wsdl(base['PutOpsPort_SERVICE'])
xml = etree.tostring(tree, pretty_print=True)
code = wsdl2py.generate_code_from_wsdl(xml, target)
m = {}
self._exec(code, m)
# XXX too much autonaming magic
m['PutOpsPort_SERVICE'] = m.pop('PutOpsPortPort_SERVICE')
if target == 'client':
m['PutOpsPortServiceStub'] = m.pop('PutOpsPortPortServiceStub')
assert_equals(sorted(m), sorted(base))
def test_parsing(self):
self.assert_parse(None, None)
self.assert_parse(None, 'nil')
self.assert_parse(XSDDate(2012, 10, 26), '2012-10-26')
self.assert_parse(XSDDate(2016, 2, 29, tzinfo=UTC), '2016-02-29Z')
parsed_date = self._parse('2012-02-29+01:00')
assert_equals(date(2012, 2, 29), parsed_date.as_datetime_date())
self.assert_same_tz(FixedOffset(1, 0, '+01:00'), parsed_date.tzinfo)
parsed_date = self._parse('2012-02-29-02:30')
assert_equals(date(2012, 2, 29), parsed_date.as_datetime_date())
self.assert_same_tz(FixedOffset(-2, -30, '-02:30'), parsed_date.tzinfo)
def test_can_render_elements_with_anonymous_simple_types(self):
element = xsdspec.Element()
element.name = 'versionNumber'
element.simpleType = xsdspec.SimpleType(
restriction=xsdspec.Restriction(base='string',
pattern=xsdspec.Pattern(
value='\d{2}\.\d{1,2}')))
expected_xml = (b'<element name="versionNumber">\n'
b' <simpleType>\n'
b' <restriction base="string">\n'
b' <pattern value="\d{2}\.\d{1,2}"/>\n'
b' </restriction>\n'
b' </simpleType>\n'
b'</element>\n')
assert_equals(expected_xml, element.xml('element'))
def test_soap11_fault_handling(self):
service = soap.Service(
location='mock_location',
methods=[],
name=None,
schemas=[],
targetNamespace=None,
version=soap.SOAPVersion.SOAP11,
)
stub = soap.Stub(location='empty', service=service)
e = assert_raises(core.SOAPError, lambda: stub._handle_response(None, None, SOAP11_ERROR_MESSAGE))
assert_equals('Result', e.code)
assert_none(e.message)
assert_equals('Resultset empty2.', e.actor)
def test_can_parse_choice_groups(self):
schema = self._choice_schema()
Result = schema.elements['result']._type
xml = '<message>foo bar</message>'
self.assert_is_valid(self._result_wrap(xml), schema)
result = Result.parse_xmlelement(etree.fromstring(xml))
assert_equals('foo bar', result.message)
assert_none(result.code)
xml = '<code>123</code>'
self.assert_is_valid(self._result_wrap(xml), schema)
result = Result.parse_xmlelement(etree.fromstring(xml))
assert_none(result.message)
assert_equals('123', result.code)
def test_can_propagate_custom_input_header(self):
handler, handler_state = echo_handler()
dispatcher = SOAPDispatcher(echo_service(handler, input_header=EchoInputHeader))
soap_header = ('<tns:InputVersion>42</tns:InputVersion>')
soap_message = (
'<tns:echoRequest>'
'<value>foobar</value>'
'</tns:echoRequest>'
)
request_message = self._wrap_with_soap_envelope(soap_message, header=soap_header)
request = SOAPRequest(dict(SOAPACTION='echo', REQUEST_METHOD='POST'), request_message)
response = dispatcher.dispatch(request)
self.assert_is_successful_response(response, handler_state)
assert_not_none(handler_state.input_header)
assert_equals('42', handler_state.input_header.InputVersion)
def test_can_correctly_determine_utc_offset(self):
# Ensure that the DateTime type really uses the correct UTC offset
# depending on the passed datetime value.
class SummerWinterTZ(tzinfo):
def utcoffset(self, dt):
if dt.month in (10, 11, 12, 1, 2, 3):
return timedelta(0)
return timedelta(hours=1)
def dst(self, dt):
return timedelta(hours=1)
tz = SummerWinterTZ()
xsd_dt = xsd.DateTime()
assert_equals('2013-11-26T00:00:00+00:00', xsd_dt.xmlvalue(datetime(2013, 11, 26, tzinfo=tz)))
assert_equals('2013-07-26T00:00:00+01:00', xsd_dt.xmlvalue(datetime(2013, 7, 26, tzinfo=tz)))
def test_can_parse_choice_groups(self):
schema = self._choice_schema()
Result = schema.elements['result']._type
xml = '<message>foo bar</message>'
self.assert_is_valid(self._result_wrap(xml), schema)
result = Result.parse_xmlelement(etree.fromstring(xml))
assert_equals('foo bar', result.message)
assert_none(result.code)
xml = '<code>123</code>'
self.assert_is_valid(self._result_wrap(xml), schema)
result = Result.parse_xmlelement(etree.fromstring(xml))
assert_none(result.message)
assert_equals('123', result.code)
def test_can_lookup_element_by_name(self):
ns = 'http://soap.example/schema.xsd'
class CodeType(xsd.String):
pattern = r'[0-9]{5}'
schema = xsd.Schema(ns,
location=ns,
elementFormDefault=xsd.ElementFormDefault.QUALIFIED,
simpleTypes=[CodeType],
elements={'code': xsd.Element(CodeType)}
)
schema_element = schema.get_element_by_name('code')
assert_equals(CodeType, schema_element._passed_type)
assert_none(schema.get_element_by_name('invalid'))
def test_can_lookup_element_by_name(self):
ns = 'http://soap.example/schema.xsd'
class CodeType(xsd.String):
pattern = r'[0-9]{5}'
schema = xsd.Schema(
ns,
location=ns,
elementFormDefault=xsd.ElementFormDefault.QUALIFIED,
simpleTypes=[CodeType],
elements={'code': xsd.Element(CodeType)})
schema_element = schema.get_element_by_name('code')
assert_equals(CodeType, schema_element._passed_type)
assert_none(schema.get_element_by_name('invalid'))
def test_can_propagate_custom_input_header(self):
handler, handler_state = echo_handler()
dispatcher = SOAPDispatcher(
echo_service(handler, input_header=EchoInputHeader))
soap_header = ('<tns:InputVersion>42</tns:InputVersion>')
soap_message = ('<tns:echoRequest>'
'<value>foobar</value>'
'</tns:echoRequest>')
request_message = self._wrap_with_soap_envelope(soap_message,
header=soap_header)
request = SOAPRequest(dict(SOAPACTION='echo', REQUEST_METHOD='POST'),
request_message)
response = dispatcher.dispatch(request)
self.assert_is_successful_response(response, handler_state)
assert_not_none(handler_state.input_header)
assert_equals('42', handler_state.input_header.InputVersion)
def test_return_soap_fault_on_exception(self):
def handler(request, _input):
raise Exception('unexpected exception')
service = echo_service(handler)
dispatcher = SOAPDispatcher(service, [ExceptionToSoapFault()])
soap_message = (
'<tns:echoRequest xmlns:tns="http://soap.example/echo/types">'
'<value>foobar</value>'
'</tns:echoRequest>'
)
request_message = self._wrap_with_soap_envelope(soap_message)
request = SOAPRequest(dict(SOAPACTION='echo', REQUEST_METHOD='POST'), request_message)
response = dispatcher.dispatch(request)
self.assert_is_soap_fault(response, fault_code=service.version.Code.SERVER,
partial_fault_string=u'Internal Error')
assert_equals('text/xml', response.http_headers['Content-Type'])
assert_equals(500, response.http_status_code)
def test_can_render_references_to_groups(self):
class Person(xsd.Group):
name = xsd.Element(xsd.String)
class Job(xsd.ComplexType):
title = xsd.Element(xsd.String)
person = xsd.Ref(Person)
job = Job()
job.person = Person(name=u'Foo Bar')
assert_equals(u'Foo Bar', job.person.name)
# TODO: actually I think the current state is invalid as title is missing?
expected_xml = (
b'<job>\n'
b' <name>Foo Bar</name>\n'
b'</job>\n'
)
assert_equals(expected_xml, job.xml('job'))
def test_can_use_soap_error_from_handler(self):
soap_error = SOAPError('code', 'internal data error', 'actor')
def faulty_handler(request, input_):
return SOAPResponse(soap_error)
dispatcher = SOAPDispatcher(echo_service(handler=faulty_handler))
soap_message = (
'<ns1:echoRequest xmlns:ns1="http://soap.example/echo/types">'
'<value>foobar</value>'
'</ns1:echoRequest>'
)
request_message = self._wrap_with_soap_envelope(soap_message)
request = SOAPRequest(dict(REQUEST_METHOD='POST'), request_message)
response = dispatcher.dispatch(request)
assert_equals('text/xml', response.http_headers['Content-Type'])
assert_equals(500, response.http_status_code)
self.assert_is_soap_fault(response, fault_code='code', partial_fault_string=u'internal data error')
def test_can_render_references_to_complex_types(self):
class Person(xsd.ComplexType):
name = xsd.Element(xsd.String)
class Job(xsd.ComplexType):
title = xsd.Element(xsd.String)
person = xsd.Ref(Person)
job = Job()
job.person = Person(name=u'Foo Bar')
assert_equals(u'Foo Bar', job.person.name)
expected_xml = (
b'<job>\n'
b' <person>\n'
b' <name>Foo Bar</name>\n'
b' </person>\n'
b'</job>\n'
)
assert_equals(expected_xml, job.xml('job'))
def test_can_render_elements_with_anonymous_simple_types(self):
element = xsdspec.Element()
element.name = 'versionNumber'
element.simpleType = xsdspec.SimpleType(
restriction=xsdspec.Restriction(
base='string',
pattern=xsdspec.Pattern(value='\d{2}\.\d{1,2}')
)
)
expected_xml = (
b'<element name="versionNumber">\n'
b' <simpleType>\n'
b' <restriction base="string">\n'
b' <pattern value="\d{2}\.\d{1,2}"/>\n'
b' </restriction>\n'
b' </simpleType>\n'
b'</element>\n'
)
assert_equals(expected_xml, element.xml('element'))
