def test_summary(mock_request):
# Given
url = 'http://www.google.com'
mock_response = Response()
mock_response.headers.get = MagicMock(return_value = 'html')
mock_response.url = url
mock_response.encoding = 'UTF-8'
mock_response.consumed = False
mock_response.raw = MagicMock()
mock_response.iter_content = lambda s: ['<html><head><title>Test Title</head><body></body></html>']
mock_request.return_value = mock_response
# When
summ = Summary(url)
# summ._html = '<html><head><title>Test Title</head><body></body></html>'
summ.extract()
# Then
# mock_response.raw.close.assert_called_with()
assert summ.title == 'Test Title'
def test_upload_app_poll_status(self):
mock_response = self.mock_post.return_value
mock_response.ok = True
mock_response.return_value = {
'success': True,
'status_url': 'http://example.com/status/'
}
response_not_completed = Response()
response_not_completed.status_code = 200
response_not_completed.encoding = 'utf-8'
response_not_completed._content = json.dumps(
{'completed': False, 'application_url': ''}).encode('utf-8')
response_completed = Response()
response_completed.status_code = 200
response_completed.encoding = 'utf-8'
response_completed._content = json.dumps(
{'completed': True, 'revision': 14,
'application_url': 'http://example.org'}).encode('utf-8')
self.mock_get.side_effect = [
response_not_completed,
response_not_completed,
response_completed,
]
response = upload_app(self.package_name, self.data)
self.assertEqual(response, {
'success': True,
'errors': [],
'application_url': 'http://example.org',
'revision': 14,
})
self.assertEqual(self.mock_get.call_count, 3)
def request_mookup(*args, **kwargs):
method = kwargs["method"]
url = kwargs["url"]
if not url.startswith(SERVER + "/"):
raise ValueError("URL [{}] does not start with [{}/].".format(
url, SERVER))
parts = url[len(SERVER) + 1:].split("?")
url = parts[0]
params = parts[1] if len(parts) > 1 else None
response = Response()
response.url = kwargs["url"]
response_file = os.path.join(RESPONSE_ROOT, url, method)
try:
with open(response_file) as f:
data = {"responses": {}, "__builtins__": {}}
exec(f.read(), data)
data = data["responses"][params]
if type(data) is dict:
if "status_code" in data:
response.status_code = data.pop("status_code")
else:
response.status_code = 200
# Extend the links with the server
for item in [None, "owner", "project", "workspace"]:
cur_dict = data if item is None else data.get(item, {})
if "links" in cur_dict:
for link in cur_dict["links"].values():
try:
link["href"] = "{}/{}".format(
SERVER, link["href"])
except:
pass
if "next" in data:
data["next"] = "{}/{}".format(SERVER, data["next"])
response.encoding = "utf-8"
response._content = bytes(json.dumps(data), response.encoding)
else:
response.status_code = 200
response._content = data
except FileNotFoundError:
response.encoding = "utf-8"
response._content = b"{}"
response.status_code = 404 # Not found
response.reason = "No stub defined [{}]".format(response_file)
except KeyError:
response.encoding = "utf-8"
response._content = b"{}"
response.status_code = 404 # Not found
response.reason = "No stub defined for param [{}]".format(params)
except Exception as e:
raise e
return response
def request_mookup(*args, **kwargs):
method = kwargs["method"]
url = kwargs["url"]
if not url.startswith(SERVER + "/"):
raise ValueError("URL [{}] does not start with [{}/].".format(url, SERVER))
parts = url[len(SERVER) + 1 :].split("?")
url = parts[0]
response_key = parts[1] if len(parts) > 1 else None
if kwargs["data"] is not None:
response_key = str(kwargs["data"])
response = Response()
response.url = kwargs["url"]
response_file = os.path.join(RESPONSE_ROOT, url, method)
try:
with open(response_file) as f:
data = {"responses": {}, "__builtins__": {}, "true": True, "false": False}
exec(f.read(), data)
data = data["responses"][response_key]
if type(data) is dict:
if "status_code" in data:
response.status_code = data.pop("status_code")
else:
response.status_code = 200
# Extend the links with the server
for item in [None, "owner", "project", "workspace"]:
# Use values of paged response
for elem in data["values"] if "values" in data else [data]:
cur_dict = elem if item is None else elem.get(item, {})
if "links" in cur_dict:
for link in cur_dict["links"].values():
for ld in link if type(link) is list else [link]:
ld["href"] = "{}/{}".format(SERVER, ld["href"])
if "next" in data:
data["next"] = "{}/{}".format(SERVER, data["next"])
response.encoding = "utf-8"
response._content = bytes(json.dumps(data), response.encoding)
else:
response.status_code = 200
response._content = data
except FileNotFoundError:
response.encoding = "utf-8"
response._content = b"{}"
response.status_code = 404 # Not found
response.reason = "No stub defined [{}]".format(response_file)
except KeyError:
response.encoding = "utf-8"
response._content = b"{}"
response.status_code = 404 # Not found
response.reason = "No stub defined for key [{}] in [{}]".format(response_key, response_file)
return response
def test_extract_response(self) -> None:
fake_response = Response()
fake_response.encoding = "UTF-8"
fake_response._content = bytes( # type: ignore
'{"a": 1}', fake_response.encoding)
self.assertEqual(self.instance.extract_response(fake_response),
{"a": 1})
def article2(self):
resp = Response()
resp.url = 'https://www.youtube.com/watch?v=scbrjaqM3Oc'
resp.encoding = 'utf8'
with open('tests/fixtures/article-2.html', 'rb') as fd:
resp._content = fd.read()
return resp
def side_effect():
response = Response()
response.status_code = 200
response._content = bytes(
'{\"metadata\": {\"total\": 1}, \"data\": [] }', 'utf-8')
response.encoding = 'utf-8'
return response
def to_requests_response(self):
"""Returns an instance of `requests.Response` based on this response.
Returns:
request.Response: the generated response.
"""
# Make sure that body is at position 0 before returning
self.body.seek(0)
urllib3_response = URLLib3Rresponse(
body=self.body,
headers=self.headers,
status=self.http_code,
request_method=self.request.method,
reason=self.reason,
preload_content=False
)
response = RequestResponse()
response.request = self.request
response.raw = urllib3_response
response.status_code = self.http_code
response.reason = self.reason
response.headers = CaseInsensitiveDict(response.raw.headers)
response.encoding = get_encoding_from_headers(response.headers)
extract_cookies_to_jar(response.cookies, self.request, urllib3_response)
if isinstance(self.request.url, six.binary_type):
response.url = self.request.url.decode("utf-8")
else:
response.url = self.request.url
return response
def test_upload_app_ignore_non_ok_responses(self):
mock_response = self.mock_post.return_value
mock_response.ok = True
mock_response.return_value = {
'success': True,
'status_url': 'http://example.com/status/',
}
ok_response = Response()
ok_response.status_code = 200
ok_response.encoding = 'utf-8'
ok_response._content = json.dumps(
{'completed': True, 'revision': 14}).encode('utf-8')
nok_response = Response()
nok_response.status_code = 503
self.mock_get.side_effect = [nok_response, nok_response, ok_response]
response = upload_app(self.package_name, self.data)
self.assertEqual(response, {
'success': True,
'errors': [],
'application_url': '',
'revision': 14,
})
self.assertEqual(self.mock_get.call_count, 3)
def test_store(self):
self.rp.decrypt_survey = MagicMock(return_value=valid_json)
self.rp.validate_survey = MagicMock()
# <store>
self.rp.send_receipt = MagicMock()
self.rp.send_notification = MagicMock()
r = Response()
with mock.patch('app.response_processor.ResponseProcessor.remote_call') as call_mock:
call_mock.return_value = r
# 500 - retry
r.status_code = 500
with self.assertRaises(RetryableError):
self._process()
# 400 - bad
r.status_code = 400
with self.assertRaises(QuarantinableError):
self._process()
# 200 - ok
r.status_code = 200
r.encoding = 'utf-8'
self._process()
def test_upload_app_ok(self):
# fake upload response
mock_response = self.mock_post.return_value
mock_response.ok = True
mock_response.return_value = {
'success': True,
'status_url': 'http://example.com/status/',
}
# fake poll status response
application_url = 'http://example.com/app/1'
revision = '1'
ok_response = Response()
ok_response.status_code = 200
ok_response.encoding = 'utf-8'
ok_response._content = json.dumps({
'completed': True,
'revision': revision,
'application_url': application_url
}).encode('utf-8')
self.mock_get.return_value = ok_response
success = upload(self.binary_file.name, 'foo')
self.assertTrue(success)
self.assertIn(
call('Application uploaded successfully (as revision {})'.format(
revision)), self.mock_logger.info.call_args_list)
self.assertIn(
call('Please check out the application at: %s\n', application_url),
self.mock_logger.info.call_args_list)
def parse_stream(response: requests.Response) -> Iterator[Mapping[str, Any]]:
"""Parses a stream response containing one detection batch.
The requests library provides utilities for iterating over the HTTP stream
response, so we do not have to worry about chunked transfer encoding. The
response is a stream of bytes that represent a json array.
Each top-level element of the json array is a detection batch. The array is
"never ending"; the server can send a batch at any time, thus
adding to the json array.
Args:
response: The requests.Response Object returned from post().
Yields:
Dictionary representations of each detection batch that was sent over the
stream.
"""
try:
if response.encoding is None:
response.encoding = "utf-8"
for line in response.iter_lines(decode_unicode=True, delimiter="\r\n"):
if not line:
continue
# Trim all characters before first opening brace, and after last closing
# brace. Example:
# Input: " {'key1': 'value1'}, "
# Output: "{'key1': 'value1'}"
json_string = "{" + line.split("{", 1)[1].rsplit("}", 1)[0] + "}"
yield json.loads(json_string)
except Exception as e: # pylint: disable=broad-except
# Chronicle's servers will generally send a {"error": ...} dict over the
# stream to indicate retryable failures (e.g. due to periodic internal
# server maintenance), which will not cause this except block to fire.
#
# In rarer cases, the streaming connection may silently fail; the
# connection will close without an error dict, which manifests as a
# requests.exceptions.ChunkedEncodingError; see
# https://github.com/urllib3/urllib3/issues/1516 for details from the
# `requests` and `urllib3` community.
#
# Instead of allowing streaming clients to crash (for ChunkedEncodingErrors,
# and for other Exceptions that may occur while reading from the stream),
# we will catch exceptions, then yield a dict containing the error,
# so the client may report the error, then retry connection (with backoff,
# and retry limit).
yield {
"error": {
"code":
500,
"status":
"UNAVAILBLE",
"message":
"exception caught while reading stream response (your "
"streaming client should retry connection): {}".format(
repr(e)),
}
}
def test_make_request(self, mocked_resp):
resp = Response()
resp.status_code = 200
resp._content = b'{"file_name": "test.yml", "env": "staging", "hash": "\xe5\xad\x97"}'
resp.encoding = 'UTF-8'
mocked_resp.return_value = resp
headers = {}
params = {
'method': 'GET',
'uri': 'https://*****:*****@host:123/path/?a=b&c=d',
'headers': headers,
'data':
b'C\xcfI\x91\xc1\xd0\tw<\xa8\x13\x06{=\x9b\xb3\x1c\xfcl\xfe\xb9\xb18zS\xf4%i*Q\xc9v',
'access_key': '',
'private_key': 'Mzjg58S93/qdg0HuVP6PsLSRDTe+fQZ5++v/mkUUx4k=',
'data_binary': True
}
r = make_request(**params)
expected = u'хнЧ'
### assert that the unicode character is in the response.text output
self.assertTrue(expected in r.text)
### assert that the unicode character is _not_ in the response.text which has been converted to bytes
self.assertFalse(expected in str(r.text.encode('utf-8')))
pass
def test_upload_app_ok_without_revision(self):
# fake upload response
mock_response = self.mock_post.return_value
mock_response.ok = True
mock_response.return_value = {
'success': True,
'status_url': 'http://example.com/status/',
}
# fake poll status response
ok_response = Response()
ok_response.status_code = 200
ok_response.encoding = 'utf-8'
ok_response._content = json.dumps(
{'completed': True}).encode('utf-8')
self.mock_get.return_value = ok_response
success = upload(self.binary_file.name)
self.assertTrue(success)
self.assertIn(
call('Application uploaded successfully.'),
self.mock_logger.info.call_args_list)
self.assertNotIn(
call('Uploaded as revision %s.', ANY),
self.mock_logger.info.call_args_list)
def test_upload_app_ignore_non_ok_responses(self):
mock_response = self.mock_post.return_value
mock_response.ok = True
mock_response.return_value = {
'success': True,
'status_url': 'http://example.com/status/',
}
ok_response = Response()
ok_response.status_code = 200
ok_response.encoding = 'utf-8'
ok_response._content = json.dumps({
'completed': True,
'revision': 14
}).encode('utf-8')
nok_response = Response()
nok_response.status_code = 503
self.mock_get.side_effect = [nok_response, nok_response, ok_response]
response = upload_app(self.package_name, self.data)
self.assertEqual(response, {
'success': True,
'errors': [],
'application_url': '',
'revision': 14,
})
self.assertEqual(self.mock_get.call_count, 3)
def test_upload_app_ok(self):
# fake upload response
mock_response = self.mock_post.return_value
mock_response.ok = True
mock_response.return_value = {
'success': True,
'status_url': 'http://example.com/status/',
}
# fake poll status response
application_url = 'http://example.com/app/1'
revision = '1'
ok_response = Response()
ok_response.status_code = 200
ok_response.encoding = 'utf-8'
ok_response._content = json.dumps(
{'completed': True, 'revision': revision,
'application_url': application_url}).encode('utf-8')
self.mock_get.return_value = ok_response
success = upload(self.binary_file.name, 'foo')
self.assertTrue(success)
self.assertIn(
call('Application uploaded successfully (as revision {})'.format(
revision)),
self.mock_logger.info.call_args_list)
self.assertIn(call('Please check out the application at: %s\n',
application_url),
self.mock_logger.info.call_args_list)
def test_store(self):
self.rp.decrypt_survey = MagicMock(return_value=valid_json)
self.rp.validate_survey = MagicMock()
# <store>
self.rp.send_receipt = MagicMock()
self.rp.send_notification = MagicMock()
r = Response()
with mock.patch('app.response_processor.ResponseProcessor.remote_call'
) as call_mock:
call_mock.return_value = r
# 500 - retry
r.status_code = 500
# Set content to keep r.json() function happy
r._content = b'{}' # pylint:disable=protected-access
with self.assertRaises(RetryableError):
self._process()
# 400 - bad
r.status_code = 400
# Set content to keep r.json() function happy
r._content = b'{}' # pylint:disable=protected-access
with self.assertRaises(QuarantinableError):
self._process()
# 200 - ok
r.status_code = 200
r.encoding = 'utf-8'
self._process()
def from_json(cls, raw, connection=None):
resp = Response()
data = json.dumps(raw)
resp._content = bytes(data, 'utf-8')
resp.encoding = 'utf-8'
resp.status_code = 200
return cls(r=resp, connection=connection)
def fake_response_handler(url=None, **kwargs):
r = Response()
r.status_code = 200
r.encoding = "utf-8"
assert url in fake_responses, "unknown URL: " + url
r._content = fake_responses[url]
return r
def test_authorized(self, mocked_class):
test_token_info = {
'https://auth.data.humancellatlas.org/email':
'*****@*****.**'
}
resp = Response()
resp.encoding = 'utf-8'
resp.status_code = 200
mocked_class.return_value = resp
@authz.authorize(self.gcp_creds, ['test:Action'],
['aws:test:resource:place:21351345134'])
def _test(token_info: dict):
pass
resp._content = json.dumps({'result': True}).encode('utf-8')
with self.subTest("result = True"):
_test(token_info=test_token_info)
resp._content = json.dumps({'result': False}).encode('utf-8')
with self.subTest("result = False"):
with self.assertRaises(AuthorizationException):
_test(token_info=test_token_info)
resp.status_code = 500
with self.subTest("Request failed"):
with self.assertRaises(AuthorizationException):
_test(token_info=test_token_info)
def build_response(request,
status_code=200,
headers={},
content='(none)'):
"""
Build a :class:`requests.Response` object on the basis of the passed
parameters.
"""
response = Response()
response.status_code = status_code
response.reason = responses[status_code]
response.headers = CaseInsensitiveDict(headers)
# Pretend that we've already read from the socket
response._content = content
response.encoding = get_encoding_from_headers(response.headers)
response.url = request.url
response.raw = MockRawResponse()
# Give the Response some context.
response.request = request
response.connection = MockConnection()
return response
def fake_response_handler(url=None, **kwargs):
r = Response()
r.status_code = 200
r.encoding = "utf-8"
assert url in fake_responses, "unknown URL: " + url
r._content = fake_responses[url]
return r
def article(self):
resp = Response()
resp.url = 'http://www.pariszigzag.fr/paris-insolite-secret/'\
'les-plus-belles-boulangeries-de-paris'
resp.encoding = 'utf8'
with open('tests/fixtures/article.html', 'rb') as fd:
resp._content = fd.read()
return resp
def test_extract_http_response_content_check_for_json_key():
response = Response()
response.status_code = 200
response.encoding = 'UTF-8'
response._content = dumps({'content': True}).encode()
response_content = core.extract_http_response_content(response)
assert 'data' in response_content
def _query_anitya_url(host_url, api_path):
assert api_path.endswith(expected_suffix)
result = Response()
result.status_code = 200
result.encoding = 'utf-8'
dummy_data = {'api_path': api_path, 'packages': dummy_packages}
result._content = json.dumps(dummy_data).encode(result.encoding)
return result
def make_response(filename, status_code = 200):
res = Response()
res.status_code = status_code
res.header = None
res.encoding = 'utf-8'
json_loaded = load_json(filename)
res._content = json.dumps(json_loaded).encode('utf-8')
return res
def build_response(request, data, code, reason, headers={}, encoding=None):
"""Builds a response object from the data"""
response = Response()
response.status_code = code
for k, v in headers.items():
response.headers[k] = v
response.encoding = encoding
if not encoding:
response.encoding = get_encoding_from_headers(response.headers)
response.raw = data
response._content = data
response.url = request.url
response.request = request
response.reason = reason
return response
def _end_request(res: Response, encoding: str) -> Response:
"""
request之后的处理，可根据逻辑重载
:param res: request之后的Response对象
:return: 处理之后的Response对象
"""
res.encoding = encoding
return res
def get_response(self, scheme='http:'):
resp = Response()
resp.url = scheme + self.response_url
resp.status_code = 200
resp.encoding = 'utf8'
resp.headers['content-type'] = 'text/html'
with open('tests/fixtures/article.html') as fd:
setattr(resp, '_content', fd.read())
return resp
async def new_response(self, response):
"""Convert an aiohttp.Response object to a requests.Response object"""
new = Response()
new._content = await response.read()
new.status_code = response.status
new.headers = response.headers
new.cookies = response.cookies
new.encoding = response.charset
return new
def _get_dummy_response(body, status_code=200) -> Response:
body_encoding = "utf-8"
body_string = body if isinstance(body, str) else json.dumps(body)
body_bytes = bytes(body_string, body_encoding)
response = Response()
response.status_code = status_code
response.encoding = body_encoding
response._content = body_bytes
return response
async def new_response(self, response):
"""Convert an aiohttp.Response object to a requests.Response object"""
new = Response()
new._content = await response.read()
new.status_code = response.status
new.headers = response.headers
new.cookies = response.cookies
new.encoding = response.charset
return new
def _response_as_json(response: requests.Response) -> Dict[Text, Any]:
"""Convert a HTTP response to json, raise exception if response failed."""
response.raise_for_status()
if response.encoding is None:
response.encoding = 'utf-8'
return response.json()
def response2(self):
resp = Response()
resp.status_code = 200
resp.url = 'https://www.youtube.com/watch?v=scbrjaqM3Oc'
resp.encoding = 'utf8'
resp.headers['content-type'] = 'text/html'
with open('tests/fixtures/article-2.html') as fd:
setattr(resp, '_content', fd.read())
return resp
def create_response(body, status, headers=None):
res = Response()
res.headers = headers
if is_third():
res._content = bytes(body, 'utf8')
res.encoding = 'utf8'
else:
res._content = body
res.status_code = status
return res
def test_send_message_json_OK(mock_send):
svc = OnapService()
mocked_response = Response()
mocked_response._content = b'{"yolo": "yala"}'
mocked_response.encoding = "UTF-8"
mocked_response.status_code = 200
mock_send.return_value = mocked_response
response = svc.send_message_json("GET", 'test get', 'http://my.url/')
mock_send.assert_called_once_with("GET", 'test get', 'http://my.url/')
assert response['yolo'] == 'yala'
def get(self, method, url, *a, **kw):
assert method == "GET"
assert url == collection_url
r = Response()
r.status_code = 200
assert responses
r._content = responses.pop().encode("utf-8")
r.headers["Content-Type"] = "text/calendar"
r.encoding = "ISO-8859-1"
return r
def get(self, method, url, *a, **kw):
assert method == 'GET'
assert url == collection_url
r = Response()
r.status_code = 200
assert responses
r._content = responses.pop().encode('utf-8')
r.headers['Content-Type'] = 'text/icalendar'
r.encoding = 'ISO-8859-1'
return r
def get(self, method, url, *a, **kw):
assert method == 'GET'
assert url == collection_url
r = Response()
r.status_code = 200
assert responses
r._content = responses.pop().encode('utf-8')
r.headers['Content-Type'] = 'text/icalendar'
r.encoding = 'ISO-8859-1'
return r
def test_send_message_json_bad_json_no_exception(mock_send):
svc = OnapService()
mocked_response = Response()
mocked_response._content = b'yolo'
mocked_response.encoding = "UTF-8"
mocked_response.status_code = 200
mock_send.return_value = mocked_response
response = svc.send_message_json("GET", 'test get', 'http://my.url/')
mock_send.assert_called_once_with("GET", 'test get', 'http://my.url/')
assert response == {}
def mock_post_response():
r = Response()
r.status_code = 200
r.encoding = "UTF-8"
r._content = str(json.dumps({
"access_token": "access_token",
"token_type": "Bearer",
"expires_in": 3599
})).encode("UTF-8")
return r
def _request(method, url, *args, **kwargs):
assert method == 'GET'
assert url == 'http://localhost:123/collection.txt'
r = Response()
r.status_code = 200
try:
with open(self.tmpfile, 'rb') as f:
r._content = f.read()
except IOError:
r._content = b''
r.headers['Content-Type'] = 'text/icalendar'
r.encoding = 'ISO-8859-1'
return r
def doQuery(self, url, method='GET', getParmeters=None, postParameters=None, files=None):
"""Send a request to the server and return the result"""
if method == 'POST':
if not files:
r = requests.post(self.baseURI + '/' + url, params=getParmeters, data=postParameters, stream=True)
else:
# Special way, for big files
# Requests is not usable: https://github.com/shazow/urllib3/issues/51
from poster.encode import multipart_encode, MultipartParam
from poster.streaminghttp import register_openers
import urllib2
# Register the streaming http handlers with urllib2
register_openers()
# headers contains the necessary Content-Type and Content-Length
# datagen is a generator object that yields the encoded parameters
data = {}
for x in postParameters:
data[x] = postParameters[x]
for f in files:
data[f] = MultipartParam(f, fileobj=open(files[f].temporary_file_path(), 'rb'), filename=files[f].name)
datagen, headers = multipart_encode(data)
# Create the Request object
request = urllib2.Request(self.baseURI + '/' + url, datagen, headers)
re = urllib2.urlopen(request)
from requests import Response
r = Response()
r.status_code = re.getcode()
r.headers = re.info()
r.encoding = "application/json"
r.raw = re.read()
r._content = r.raw
return r
else:
# Call the function based on the method.
r = getattr(requests, method.lower())(self.baseURI + '/' + url, params=getParmeters, stream=True)
return r
def _request(method, url, *args, **kwargs):
assert method == 'GET'
assert url == 'http://localhost:123/collection.txt'
assert 'vdirsyncer' in kwargs['headers']['User-Agent']
r = Response()
r.status_code = 200
try:
with open(self.tmpfile, 'rb') as f:
r._content = f.read()
except IOError:
r._content = b''
r.headers['Content-Type'] = 'text/calendar'
r.encoding = 'utf-8'
return r
def test_repo_helper(self):
helper = RepoHelper(self.repo1.working_dir)
self.assertEqual(helper.active_branch_name(), 'master')
self.assertEqual(
helper.default_index_prefix(),
os.path.basename(self.repo1.working_dir))
helper = RepoHelper('http://localhost/repos/repo1.json')
with patch.object(helper.rsm, 'mk_request') as mock:
response = Response()
response.encoding = 'utf-8'
response._content = json.dumps({'branch': 'foo'})
mock.return_value = response
self.assertEqual(helper.active_branch_name(), 'foo')
self.assertEqual(helper.default_index_prefix(), 'repo1')
def build_response(request, data, code, encoding):
'''Builds a response object from the data returned by ftplib, using the
specified encoding.'''
response = Response()
response.encoding = encoding
# Fill in some useful fields.
response.raw = data
response.url = request.url
response.request = request
response.status_code = code.split()[0]
# Make sure to seek the file-like raw object back to the start.
response.raw.seek(0)
# Run the response hook.
response = dispatch_hook('response', request.hooks, response)
return response
def build_response(request, data, code, encoding):
response = Response()
response.encoding = encoding
# Fill in some useful fields.
raw = StringIO()
raw.write(data)
raw.seek(0)
response.raw = raw
response.url = request.url
response.request = request
response.status_code = code
# Run the response hook.
response = dispatch_hook('response', request.hooks, response)
return response
def build_response(request, data, code, encoding):
'''Builds a response object from the data returned by ftplib, using the
specified encoding.'''
response = Response()
response.encoding = encoding
# Fill in some useful fields.
response.raw = data
response.url = request.url
response.request = request
response.status_code = int(code.split()[0])
if hasattr(data, "content_len"):
response.headers['Content-Length'] = str(data.content_len)
# Make sure to seek the file-like raw object back to the start.
response.raw.seek(0)
# Run the response hook.
response = dispatch_hook('response', request.hooks, response)
return response
def build_response(request, data, code, encoding):
'''Builds a response object from the data returned by ftplib, using the
specified encoding.'''
response = Response()
response.encoding = encoding
# Fill in some useful fields.
raw = StringIO()
raw.write(data)
raw.seek(0)
response.raw = raw
response.url = request.url
response.request = request
response.status_code = code
# Run the response hook.
response = dispatch_hook('response', request.hooks, response)
return response
def build_response(self, req, resp):
response = Response()
response.status_code = resp.status_code
response.headers = CaseInsensitiveDict((k, v) for k, v in resp.items())
response.encoding = get_encoding_from_headers(response.headers)
response.raw = StringIO(resp.content)
response.reason = None
if isinstance(req.url, bytes):
response.url = req.url.decode('utf-8')
else:
response.url = req.url
# Convert from django's SimpleCookie to request's CookieJar
cookiejar_from_dict(resp.cookies, response.cookies)
# context
response.request = req
response.connection = self
response = dispatch_hook('response', req.hooks, response)
return response
def get_response(self, content=b'', status_code=200):
response = Response()
response.status_code = status_code
response._content = content
response.encoding = 'utf-8'
return response
def send(self, request, stream=False, verify=None, cert=None, proxies=None,
timeout=None):
"""issue request"""
data = url_unquote(request.url[len('data:'):])
if ',' not in data:
raise InvalidURL('data URL missing comma')
mime, content = data.split(',', 1)
content = content.strip()
base64 = False
charset = None
while ';' in mime:
mime, encoding_spec = mime.rsplit(';', 1)
encoding_spec = encoding_spec.strip()
if encoding_spec == 'base64':
base64 = True
elif not encoding_spec.startswith('charset='):
raise InvalidURL(
'unrecognized encoding parameter: %r' % encoding_spec
)
else:
charset = encoding_spec[len('charset='):]
try:
if base64:
content = a2b_base64(content)
content_type = mime.strip()
if charset:
content_type += "; charset=" + charset
response = Response()
response.url = request.url
response.headers['Date'] = formatdate(timeval=None, localtime=True)
if request.method in ('GET', 'HEAD'):
response.status_code = 200
response.headers['Content-Length'] = len(content)
response.headers['Last-Modified'] = formatdate()
response.headers['Content-Type'] = content_type
if charset:
response.encoding = charset
response.raw = StringIO(str(content))
else:
response.status_code = 405
response.headers['Status'] = '405 Method Not Allowed'
except Exception:
response.status_code = 500
response.headers['Status'] = '500 Internal Server Error'
response.raw = StringIO(format_exc())
# context
response.request = request
response.connection = self
# hooks
response = dispatch_hook('response', request.hooks, response)
# streaming
if not stream:
response.content
return response
def doQuery(self, url, method='GET', getParmeters=None, postParameters=None, files=None, extraHeaders={}, session={}):
"""Send a request to the server and return the result"""
# Build headers
headers = {}
for key, value in extraHeaders.iteritems():
headers['X-Plugit-' + key] = value
for key, value in session.iteritems():
headers['X-Plugitsession-' + key] = value
if method == 'POST':
if not files:
r = requests.post(self.baseURI + '/' + url, params=getParmeters, data=postParameters, stream=True, headers=headers)
else:
# Special way, for big files
# Requests is not usable: https://github.com/shazow/urllib3/issues/51
from poster.encode import multipart_encode, MultipartParam
from poster.streaminghttp import register_openers
import urllib2
# Register the streaming http handlers with urllib2
register_openers()
# headers contains the necessary Content-Type and Content-Length
# datagen is a generator object that yields the encoded parameters
data = []
for x in postParameters:
if isinstance(postParameters[x], list):
for elem in postParameters[x]:
data.append((x, elem))
else:
data.append((x, postParameters[x]))
for f in files:
data.append((f, MultipartParam(f, fileobj=open(files[f].temporary_file_path(), 'rb'), filename=files[f].name)))
datagen, headers_multi = multipart_encode(data)
headers.update(headers_multi)
# Create the Request object
request = urllib2.Request(self.baseURI + '/' + url, datagen, headers)
re = urllib2.urlopen(request)
from requests import Response
r = Response()
r.status_code = re.getcode()
r.headers = dict(re.info())
r.encoding = "application/json"
r.raw = re.read()
r._content = r.raw
return r
else:
# Call the function based on the method.
r = requests.request(method.upper(), self.baseURI + '/' + url, params=getParmeters, stream=True, headers=headers, allow_redirects=True)
return r
def json_respnse(data):
result = Response()
result.encoding = "application/json"
result.raw = BytesIO(json.dumps(data))
result.status_code = 200
return result
