def test_DocumentCache(tmpdir):
cacheFolder = tmpdir.join("puffy").strpath
cache = suds.cache.DocumentCache(cacheFolder)
assert isinstance(cache, suds.cache.FileCache)
assert cache.get("unga1") is None
# TODO: DocumentCache class interface seems silly. Its get() operation
# returns an XML document while its put() operation takes an XML element.
# The put() operation also silently ignores passed data of incorrect type.
# TODO: Update this test to no longer depend on the exact input XML data
# formatting. We currently expect it to be formatted exactly as what gets
# read back from the DocumentCache.
content = suds.byte_str("""\
<xsd:element name="Elemento">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="alfa"/>
<xsd:enumeration value="beta"/>
<xsd:enumeration value="gamma"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>""")
xml = suds.sax.parser.Parser().parse(suds.BytesIO(content))
cache.put("unga1", xml.getChildren()[0])
readXML = cache.get("unga1")
assert isinstance(readXML, suds.sax.document.Document)
readXMLElements = readXML.getChildren()
assert len(readXMLElements) == 1
readXMLElement = readXMLElements[0]
assert isinstance(readXMLElement, suds.sax.element.Element)
assert suds.byte_str(str(readXMLElement)) == content
def parse(self, file=None, string=None):
"""
SAX parse XML text.
@param file: Parse a python I{file-like} object.
@type file: I{file-like} object
@param string: Parse string XML.
@type string: str
@return: Parsed XML document.
@rtype: L{Document}
"""
if file is None and string is None:
return
timer = metrics.Timer()
timer.start()
source = file
if file is None:
source = InputSource(None)
source.setByteStream(suds.BytesIO(string))
sax, handler = self.saxparser()
sax.parse(source)
timer.stop()
if file is None:
metrics.log.debug("%s\nsax duration: %s", string, timer)
else:
metrics.log.debug("sax (%s) duration: %s", file, timer)
return handler.nodes[0]
def open(self, request):
"""
Perform an HTTP GET to the URL in the given suds.transport.Request and returns
a file-like object of the request body.
"""
response = None
try:
if self.verify_ssl and request.url.startswith('http://'):
if self.rewrite_to_https:
request.url = 'https://' + request.url[7:]
else:
raise SSLError("can't verify SSL certificate with plain HTTP link")
response = self.session.get(
url=request.url,
data=request.message,
headers=request.headers,
proxies=self.proxy,
verify=self.verify_ssl,
cert=self.getclientcertificate(),
)
response.raise_for_status()
except SSLError as e:
raise TransportError(str(e), None)
except (RequestException, HTTPError, ConnectionError) as e:
raise TransportError(str(e), None)
return suds.BytesIO(response.content)
def construct_XML(element_name="Elemento"):
"""
Construct XML content and an Element wrapping it.
Constructed content may be parametrized with the given element name.
"""
# TODO: Update the tests in this group to no longer depend on the exact
# input XML data formatting. They currently expect it to be formatted
# exactly as what gets read back from their DocumentCache.
content = suds.byte_str("""\
<xsd:element name="%s">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="alfa"/>
<xsd:enumeration value="beta"/>
<xsd:enumeration value="gamma"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>""" % (element_name, ))
xml = suds.sax.parser.Parser().parse(suds.BytesIO(content))
children = xml.getChildren()
assert len(children) == 1
assert children[0].__class__ is suds.sax.element.Element
return content, children[0]
def create_test_document():
input_data = suds.byte_str("""\
<xsd:element name="ZuZu">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="alfa"/>
<xsd:enumeration value="beta"/>
<xsd:enumeration value="gamma"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>""")
document = suds.sax.parser.Parser().parse(suds.BytesIO(input_data))
assert document.__class__ is Document
return document
def parse(self, file=None, string=None):
"""
SAX parse XML text.
@param file: Parse a python I{file-like} object.
@type file: I{file-like} object.
@param string: Parse string XML.
@type string: str
"""
timer = suds.metrics.Timer()
timer.start()
sax, handler = self.saxparser()
if file is not None:
sax.parse(file)
timer.stop()
suds.metrics.log.debug('sax (%s) duration: %s', file, timer)
return handler.nodes[0]
if string is not None:
source = InputSource(None)
source.setByteStream(suds.BytesIO(string))
sax.parse(source)
timer.stop()
suds.metrics.log.debug('%s\nsax duration: %s', string, timer)
return handler.nodes[0]
def send(self, request):
"""converts the suds request into requests.request and HTTP POSTs
to the url given in the @request.
If verify_ssl is True, then performs some additional checks to make sure
SSL is being handled in a sane fashion."""
result = None
try:
if self.verify_ssl and request.url.startswith('http://'):
if self.rewrite_to_https:
request.url = 'https://' + request.url[7:]
else:
raise SSLError("can't verify SSL certificate with plain HTTP link")
#
response = self.session.post(
url=request.url,
headers=request.headers,
data=request.message,
proxies=self.proxy,
verify=self.verify_ssl,
auth=self.getcredentials(),
cert=self.getclientcertificate()
)
result = Reply(response.status_code, response.headers, response.content)
response.raise_for_status()
if response.status_code == 401:
#TODO do something useful
raise TransportError(response.status_code)
except SSLError as e:
raise TransportError(str(e), None)
except (HTTPError, ConnectionError, RequestException) as e:
if e.response.status_code in (202, 204):
result = None
else:
raise TransportError(str(e), e.response.status_code, suds.BytesIO(e.response.content))
return result
def construct_XML(element_name="Elemento"):
"""
Construct XML content and a Document wrapping it.
The XML contains a single Element (may be parametrized with the given
element name) and possibly additional sub-elements under it.
"""
#TODO: Update the tests in this group to no longer depend on the exact
# input XML data formatting. They currently expect it to be formatted
# exactly as what gets read back from their DocumentCache.
content = suds.byte_str("""\
<xsd:element name="%s">
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="alfa"/>
<xsd:enumeration value="beta"/>
<xsd:enumeration value="gamma"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>""" % (element_name,))
xml = suds.sax.parser.Parser().parse(suds.BytesIO(content))
assert xml.__class__ is suds.sax.document.Document
return content, xml
def send(self, request):
self.mock_operation_log.append(("send", request.url))
if self.mock_send_data:
return suds.BytesIO(self.mock_send_data.pop(0))
pytest.fail("Unexpected MockTransport.send() operation call.")
def create_test_element(content=str_formatted_xml):
input_data = suds.byte_str(content)
xml = suds.sax.parser.Parser().parse(suds.BytesIO(input_data))
element = xml.root()
assert element.__class__ is Element
return element
def open(self, request):
self.mock_log.append(("open", [request.url]))
if not self.mock_open_data:
pytest.fail("Unexpected MockTransport.open() operation call.")
result = self.__next_operation_result(self.mock_open_data)
return suds.BytesIO(result)
