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 from_client_response(cls,
client_response: ClientResponse,
expires: datetime = None):
"""Convert a ClientResponse into a CachedReponse"""
if isinstance(client_response, cls):
return client_response
# Copy most attributes over as is
copy_attrs = set(attr.fields_dict(cls).keys()) - EXCLUDE_ATTRS
response = cls(**{k: getattr(client_response, k) for k in copy_attrs})
# Read response content, and reset StreamReader on original response
if not client_response._released:
await client_response.read()
response._body = client_response._body
client_response.content = CachedStreamReader(client_response._body)
# Set remaining attributes individually
response.expires = expires
response.links = client_response.links
response.real_url = client_response.request_info.real_url
# The encoding may be unset even if the response has been read, and
# get_encoding() does not handle certain edge cases like an empty response body
try:
response.encoding = client_response.get_encoding()
except (RuntimeError, TypeError):
pass
if client_response.history:
response.history = (*[
await cls.from_client_response(r)
for r in client_response.history
], )
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 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
