def make_http_response(
status=200, reason="OK", method="GET", url="/", headers=None, content=None
):
"""Return a minimal ClientResponse with fields used in tests."""
url = URL(url)
headers = CIMultiDict(headers or {})
request_info = RequestInfo(url=url, method=method, headers=headers)
response = ClientResponse(
method,
url,
writer=None,
continue100=None,
timer=None,
request_info=request_info,
traces=(),
loop=get_event_loop(),
session=None,
)
response.status = status
response.reason = reason
response._headers = headers
if isinstance(content, io.IOBase):
response.content = FakeStreamReader(content)
elif content is not None:
response.content = FakeStreamReader(
io.BytesIO(json_dumps(content).encode("utf8"))
)
response.headers["Content-Type"] = "application/json"
return response
async def test_iter_content_generator():
"""Test CRLF -> LF newline conversion."""
async def mock_iter_content(n):
for chunk in [b'1\r\n2\r\n', b'3\r', b'\n4', b'\r\n5']:
yield chunk
response = ClientResponse(
'get',
ST_URL,
request_info=Mock(),
writer=Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=Mock(),
session=Mock(),
)
response._headers = {'Content-Type': 'application/json;charset=utf-8'}
with patch.object(response, 'content',
Mock(iter_chunked=mock_iter_content)):
result = [
line async for line in _iter_content_generator(response=response,
decode_unicode=True)
]
assert result == ['1\n2\n', '3', '\n4', '\n5']
result = [
line
async for line in _iter_content_generator(response=response,
decode_unicode=False)
]
assert result == [b'1\r\n2\r\n', b'3\r', b'\n4', b'\r\n5']
def make_response(loop,
method,
url,
data=None,
content_type='text/plain',
charset='utf-8'):
if LooseVersion(aiohttp_version) >= LooseVersion('3.3.0'):
response = ClientResponse(method,
URL(url),
writer=mock.Mock(),
continue100=None,
timer=None,
request_info=mock.Mock(),
traces=[],
loop=loop,
session=mock.Mock())
elif LooseVersion(aiohttp_version) >= LooseVersion('3.1.0'):
response = ClientResponse(method,
URL(url),
writer=mock.Mock(),
continue100=None,
timer=None,
request_info=mock.Mock(),
auto_decompress=True,
traces=[],
loop=loop,
session=mock.Mock())
else:
response = ClientResponse(method,
URL(url),
writer=mock.Mock(),
continue100=None,
timer=None,
request_info=mock.Mock(),
auto_decompress=True)
response._post_init(loop, mock.Mock())
def side_effect(*args, **kwargs):
fut = loop.create_future()
fut.set_result(str(data).encode(charset))
return fut
if LooseVersion(aiohttp_version) >= LooseVersion('3.3.0'):
response._headers = {
'Content-Type': '%s; charset=%s' % (content_type, charset)
}
else:
response.headers = {
'Content-Type': '%s; charset=%s' % (content_type, charset)
}
content = response.content = mock.Mock()
if data:
content.read.side_effect = side_effect
return response
def build_response(self, method, url, params, data, headers):
""""""
try:
if type(url) == URL:
url = url.human_repr()
# Check if we have to skip it
if self.skip(url):
return None, True
# Go check see if response is in cassette
if not data:
data = {}
if params:
data.update(params)
request = vcr.request.Request(method, url, data, headers)
cassette = self.load_cassette(url)
resp_json = cassette.play_response(request)
except UnhandledHTTPRequestError:
# Response not seen yet in cassette
return None, False
# Response was found in cassette
cassette.play_counts = collections.Counter()
# Create the response
resp = ClientResponse(
method,
URL(url),
request_info=Mock(),
writer=Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=Mock(),
session=Mock(),
)
# Replicate status code and reason
resp.status = resp_json['status']['code']
resp.reason = resp_json['status']['message']
# Set headers and content
resp._headers = CIMultiDict(resp_json['headers'])
resp.content = StreamReader(Mock(), limit=DEFAULT_STREAM_LIMIT)
# Get the data
data = resp_json['body']['data']
resp.content.feed_data(data)
resp.content.feed_eof()
return resp, False
async def request(self, *args, **kwargs) -> ClientResponse:
try:
data = self.requests.pop(0)
response = ClientResponse('get',
URL('http://def-cl-resp.org'),
request_info=mock.Mock(),
writer=mock.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=asyncio.get_running_loop(),
session=mock.Mock())
response.status = 200
response._body = data
response._headers = {'Content-Type': 'application/json'}
return response
except IndexError as e:
print(f'error in pop requests')
raise Exception(str(e)) from e
async def build_response(self,
session,
method,
url,
params=None,
data=None,
headers=None,
*args,
**kwargs):
self.requests.append({
'method': method,
'url': url,
'params': params,
'data': data,
'headers': headers
})
url = URL(url)
url_parts = [p.split('?')[-1] for p in url.parts]
if data is None and 'json' in kwargs:
data = json.dumps(kwargs['json'])
resp = ClientResponse(
method,
url,
request_info=Mock(),
writer=Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=Mock(),
session=Mock(),
)
func_name = '_'.join(url_parts[-2:])
func = None
if hasattr(self, func_name):
func = getattr(self, func_name)
else:
func_name = url_parts[-1]
if hasattr(self, func_name):
func = getattr(self, func_name)
if func is not None:
status, data, ct = await func(params or url.query, data, headers)
resp.status = status
else:
print(f'Method {func_name} not implemented')
resp.status = 200
if method.lower() == 'patch':
resp.status = 204
ct = 'application/json'
data = '{}'
resp._headers = CIMultiDict({hdrs.CONTENT_TYPE: ct})
loop = asyncio.get_event_loop()
protocol = Mock(_reading_paused=False)
resp.content = StreamReader(protocol,
loop=loop,
limit=DEFAULT_STREAM_LIMIT)
if isinstance(data, str):
data = data.encode('utf8')
resp.content.feed_data(data)
resp.content.feed_eof()
self.responses.append(resp)
return resp
