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
def build_response(self):
if isinstance(self.exception, Exception):
raise self.exception
self.resp = ClientResponse(self.method, URL(self.url))
# we need to initialize headers manually
self.resp.headers = CIMultiDict({hdrs.CONTENT_TYPE: self.content_type})
if self.headers:
self.resp.headers.update(self.headers)
self.resp.status = self.status
self.resp.content = StreamReader()
self.resp.content.feed_data(self.body)
self.resp.content.feed_eof()
return self.resp
def build_response(self, method: str, url: str, payload: str, *,
session: ClientSession, status: int) -> ClientResponse:
response = session._response_class(
method,
URL(url),
request_info=self.mock_module.Mock(),
writer=self.mock_module.Mock(),
continue100=None,
timer=TimerNoop(),
traces=[],
loop=session.loop,
session=session)
response._headers = CIMultiDictProxy(
CIMultiDict({'Content-Type': 'application/json'}))
response.status = status
if status >= 400:
response.reason = payload
response.content = StreamReader(ResponseHandler(session.loop))
response.content.feed_data(str.encode(payload))
response.content.feed_eof()
return response
def content(self):
protocol = Mock(_reading_paused=False)
stream = StreamReader(protocol)
stream.feed_data(self.body)
stream.feed_eof()
return stream
def stream_reader_factory():
return StreamReader()
def stream_reader_factory(
loop: 'Optional[asyncio.AbstractEventLoop]' = None):
protocol = ResponseHandler(loop=loop)
return StreamReader(protocol)
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
def stream_reader_factory():
protocol = ResponseHandler()
return StreamReader(protocol)
def stream_reader_factory(loop=None):
return StreamReader()
def stream_reader():
return StreamReader()