def download(self, url):
"""
Download the docuemnt.
@param url: A document url.
@type url: str.
@return: A file pointer to the docuemnt.
@rtype: file-like
"""
store = DocumentStore()
fp = store.open(url)
if fp is None:
fp = self.options.transport.open(Request(url))
content = fp.read()
fp.close()
ctx = self.plugins.document.loaded(url=url, document=content)
content = ctx.document
sax = Parser()
return sax.parse(string=content)
def send(self, soapenv):
"""
Send soap message.
@param soapenv: A soap envelope to send.
@type soapenv: L{Document}
@return: The reply to the sent message.
@rtype: I{builtin} or I{subclass of} L{Object}
"""
result = None
location = self.location()
binding = self.method.binding.input
transport = self.options.transport
retxml = self.options.retxml
prettyxml = self.options.prettyxml
log.debug('sending to (%s)\nmessage:\n%s', location, soapenv)
try:
self.last_sent(soapenv)
plugins = PluginContainer(self.options.plugins)
plugins.message.marshalled(envelope=soapenv.root())
if prettyxml:
soapenv = soapenv.str()
else:
soapenv = soapenv.plain()
soapenv = soapenv.encode('utf-8')
result = plugins.message.sending(envelope=soapenv)
if (result):
soapenv = result.envelope
request = Request(location, soapenv)
request.headers = self.headers()
reply = transport.send(request)
ctx = plugins.message.received(reply=reply.message)
reply.message = ctx.reply
if retxml:
result = reply.message
else:
result = self.succeeded(binding, reply.message)
except TransportError as e:
if e.httpcode in (202, 204):
result = None
else:
log.error(self.last_sent())
result = self.failed(binding, e)
return result
def open(self, url):
"""
Open an XML document at the specified I{url}.
First, the document attempted to be retrieved from
the I{document cache}. If not found, it is downloaded and
parsed using the SAX parser. The result is added to the
document store for the next open().
@param url: A document url.
@type url: str.
@return: The specified XML document.
@rtype: I{Document}
"""
d = self.options.cache.get(url)
if d is None:
fp = self.options.transport.open(Request(url))
sax = Parser()
d = sax.parse(file=fp)
#self.options.cache.put(url, d)
return d
def test_send(self):
""" Verify the send method POSTs data to the API and returns a Reply object. """
request = Request(API_URL)
body = str(uuid.uuid4())
httpretty.register_uri(httpretty.POST,
API_URL,
body=body,
content_type=CONTENT_TYPE,
forcing_headers={'date': 'never'})
transport = RequestsTransport()
response = transport.send(request)
self.assertEqual(response.code, 200)
self.assertEqual(response.headers, {
'date': 'never',
'content-type': CONTENT_TYPE
})
self.assertEqual(response.message, body)
def test_string_representation_with_message(self, url, headers, message):
for key, value in headers.items():
old_key = key
if isinstance(key, text_type):
key = key.encode("utf-8")
del headers[old_key]
if isinstance(value, text_type):
value = value.encode("utf-8")
headers[key] = value
if isinstance(message, text_type):
message = message.encode("utf-8")
request = Request(url, message)
request.headers = headers
expected = u("""\
URL: %s
HEADERS: %s
MESSAGE:
%s""") % (url, request.headers, message.decode("raw_unicode_escape"))
assert text_type(request) == expected
if sys.version_info < (3, ):
assert str(request) == expected.encode("utf-8")
def parse(self, file=None, url=None, string=None):
""" parse a document """
handler = Handler()
timer = metrics.Timer()
timer.start()
if file is not None:
parse(file, handler)
timer.stop()
metrics.log.debug('sax (%s) duration: %s', file, timer)
return handler.nodes[0]
if url is not None:
fp = self.transport.open(Request(url))
parse(fp, handler)
timer.stop()
metrics.log.debug('sax (%s) duration: %s', url, timer)
return handler.nodes[0]
if string is not None:
parseString(string, handler)
timer.stop()
metrics.log.debug('%s\nsax duration: %s', string, timer)
return handler.nodes[0]
def test_request_as_string(message):
request = Request("my url", message)
request.headers["aaa"] = 1
expected = """\
URL: my url
HEADERS: %s
MESSAGE:
%s""" % (request.headers, message)
assert str(request) == expected
if sys.version_info < (3, 0):
assert str(request) == expected.encode("utf-8")
def download(self, url):
"""
Download the document.
@param url: A document URL.
@type url: str.
@return: A file pointer to the document.
@rtype: file-like
"""
content = None
store = self.options.documentStore
if store is not None:
content = store.open(url)
if content is None:
fp = self.options.transport.open(Request(url))
try:
content = fp.read()
finally:
fp.close()
ctx = self.plugins.document.loaded(url=url, document=content)
content = ctx.document
sax = Parser()
return sax.parse(string=content)
def send(self, soapenv):
"""
Send soap message.
@param soapenv: A soap envelope to send.
@type soapenv: L{Document}
@return: The reply to the sent message.
@rtype: I{builtin} or I{subclass of} L{Object}
"""
location = self.location()
log.debug('sending to (%s)\nmessage:\n%s', location, soapenv)
original_soapenv = soapenv
plugins = PluginContainer(self.options.plugins)
plugins.message.marshalled(envelope=soapenv.root())
if self.options.prettyxml:
soapenv = soapenv.str()
else:
soapenv = soapenv.plain()
soapenv = soapenv.encode('utf-8')
ctx = plugins.message.sending(envelope=soapenv)
soapenv = ctx.envelope
if self.options.nosend:
return RequestContext(self, soapenv, original_soapenv)
request = Request(location, soapenv)
request.headers = self.headers()
try:
timer = metrics.Timer()
timer.start()
reply = self.options.transport.send(request)
timer.stop()
metrics.log.debug('waited %s on server reply', timer)
except TransportError as e:
content = e.fp and e.fp.read() or ''
return self.process_reply(reply=content,
status=e.httpcode,
description=tostr(e),
original_soapenv=original_soapenv)
return self.process_reply(reply=reply.message,
original_soapenv=original_soapenv)
def test_construct_with_no_message(self):
request = Request("some://url")
assert request.headers == {}
assert request.message is None
def test_request_without_message():
request = Request("for a bitch it's haaaard...")
assert request.url == "for a bitch it's haaaard..."
assert request.message is None
assert request.headers == {}
def test_request_constructor(url, message):
request = Request(url, message)
assert request.url == url
assert request.message == message
assert request.headers == {}
