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)