def http_post(reactor, url, value):
agent = client.Agent(reactor)
d = agent.request('POST', url,
headers=client.Headers({'Content-Type': ['application/json']}),
# in principle this could be streaming if we had a pipe-thing to glue between json.dump and FileBodyProducer
bodyProducer=client.FileBodyProducer(StringIO.StringIO(json.dumps(value))))
return _handle_agent_response(d)
def request(self,
method,
url,
content=None,
state=http.OK,
add_headers=None):
body = None if content is None else client.FileBodyProducer(
StringIO(content))
headers = {
'Content-Type': ['application/json'],
'X-WebAuth-User': ['tester']
}
if add_headers:
headers.update(add_headers)
response = yield self.client.request(method, self.url_prefix + url,
Headers(headers), body)
self.assertEqual(state, response.code)
body_receiver = BodyReceiver()
response.deliverBody(body_receiver)
body = yield body_receiver.finished
if response.headers.getRawHeaders('content-type') == [
'application/json'
]:
body = anyjson.loads(body)
returnValue((response, body))
def do_return():
# This looks a bit too complicated for just POSTing a string,
# but there seems to be no other way. Blame Twisted.
# agent.request() will add content-length based on length
# from FileBodyProducer. If we have another in headers,
# there will be a duplicate, so remove it.
headers.removeHeader('content-length')
producer = client.FileBodyProducer(StringIO(body))
d = self.agent.request('POST', url.encode('utf-8'), headers,
producer)
@defer.inlineCallbacks
def _response(r):
if r.code != 200:
log.error(
'return error: server responded with status" \
"code {r.code}, response body follows...', r)
bodyD = yield client.readBody(r)
log.debug(bodyD)
raise RuntimeError('Failed to return task')
d.addCallback(_response)
return d
def sendTrigger(self, trigger):
body = client.FileBodyProducer(StringIO(trigger))
response = yield self.client.request(
'PUT', self.url_prefix + 'trigger/{0}'.format(self.trigger.id),
Headers({'Content-Type': ['application/json']}), body)
self.assertEqual(http.OK, response.code)
returnValue(anyjson.loads(trigger))
def http_request(reactor, url, method, body=None, accept=None, more_headers=None):
agent = client.Agent(reactor)
headers = Headers()
if accept is not None:
headers.addRawHeader('Accept', str(accept))
if more_headers:
for k, v in more_headers.iteritems():
headers.addRawHeader(str(k), str(v))
d = agent.request(
method=str(method),
uri=str(url),
headers=headers,
bodyProducer=client.FileBodyProducer(StringIO.StringIO(str(body))) if body else None)
return _handle_agent_response(d)
def test_errorXMLContent(self):
"""
Test that an invalid XML input returns an L{xmlrpc.Fault}.
"""
agent = client.Agent(reactor)
d = agent.request(
uri=networkString("http://127.0.0.1:%d/" % (self.port,)),
method=b"POST",
bodyProducer=client.FileBodyProducer(BytesIO(b"foo")))
d.addCallback(client.readBody)
def cb(result):
self.assertRaises(xmlrpc.Fault, xmlrpclib.loads, result)
d.addCallback(cb)
return d
def http_request(reactor, url, method, body=None, accept=None, more_headers=None):
agent = client.Agent(reactor)
headers = Headers()
if accept is not None:
headers.addRawHeader('Accept', bytes_or_ascii(accept))
if more_headers:
for k, v in six.iteritems(more_headers):
headers.addRawHeader(bytes_or_ascii(k), bytes_or_ascii(v))
d = agent.request(
method=bytes_or_ascii(method),
uri=bytes_or_ascii(url),
headers=headers,
bodyProducer=client.FileBodyProducer(six.BytesIO(bytes_or_ascii(body))) if body else None)
return _handle_agent_response(d)
def testReadAllInput(self):
cgiFilename = os.path.abspath(self.mktemp())
with open(cgiFilename, 'wt') as cgiFile:
cgiFile.write(READALLINPUT_CGI)
portnum = self.startServer(cgiFilename)
d = client.Agent(reactor).request(
uri="http://localhost:%d/cgi" % (portnum,),
method=b"POST",
bodyProducer=client.FileBodyProducer(
BytesIO(b"Here is your stdin")),
)
d.addCallback(client.readBody)
d.addCallback(self._testReadAllInput_1)
return d
def test_ReadInput(self):
cgiFilename = os.path.abspath(self.mktemp())
with open(cgiFilename, "wt") as cgiFile:
cgiFile.write(READINPUT_CGI)
portnum = self.startServer(cgiFilename)
agent = client.Agent(reactor)
url = "http://localhost:%d/cgi" % (portnum,)
url = url.encode("ascii")
d = agent.request(
uri=url,
method=b"POST",
bodyProducer=client.FileBodyProducer(BytesIO(b"Here is your stdin")),
)
d.addCallback(client.readBody)
d.addCallback(self._test_ReadInput_1)
return d
def render(self, request):
#Recreate and fix up the headers
headers = {
k.decode("UTF-8"): [v.decode("UTF-8")]
for k, v in request.getAllHeaders().items()
}
#Content-Length is set by the agent, having it set here will cause 2 headers to be sent
for header in [
"content-length", "host", "transfer-encoding",
"accept-encoding"
]:
if header in headers:
del headers[header]
headers["connection"] = ["close"]
for header, value in self.headers.items():
headers[header] = [value]
deferred = self.agent.request(request.method.decode("UTF-8"), self.uri,
http_headers.Headers(headers),
client.FileBodyProducer(request.content))
deferred.addCallback(self.deliver_deferred_response, request)
deferred.addErrback(self.deliver_deferred_error, request)
return server.NOT_DONE_YET
