def data_received(self, data):
'''Implements :meth:`~.ProtocolConsumer.data_received` method.
Once we have a full HTTP message, build the wsgi ``environ`` and
delegate the response to the :func:`wsgi_callable` function.
'''
parser = self.parser
processed = parser.execute(data, len(data))
if not self._stream and parser.is_headers_complete():
headers = Headers(parser.get_headers(), kind='client')
self._stream = StreamReader(headers, parser, self.transport)
self._response(self.wsgi_environ())
#
if parser.is_message_complete():
#
# Stream has the whole body
if not self._stream.on_message_complete.done():
self._stream.on_message_complete.set_result(None)
if processed < len(data):
if not self._buffer:
self._buffer = data[processed:]
self.bind_event('post_request', self._new_request)
else:
self._buffer += data[processed:]
#
elif processed < len(data):
# This is a parsing error, the client must have sent
# bogus data
raise ProtocolError
def __init__(self, url, username, password, **kwargs):
super(GerritSession, self).__init__(
headers=Headers([('Content-Type', 'application/json')]),
**kwargs
)
self.url = url
self.auth = HTTPDigestAuth(username, password)
def test_CacheControl(self):
headers = Headers()
c = CacheControl()
self.assertFalse(c.private)
self.assertFalse(c.maxage)
c(headers)
self.assertEqual(headers['cache-control'], 'no-cache')
c = CacheControl(maxage=3600)
c(headers)
self.assertEqual(headers['cache-control'], 'max-age=3600, public')
c = CacheControl(maxage=3600, private=True)
c(headers)
self.assertEqual(headers['cache-control'], 'max-age=3600, private')
c = CacheControl(maxage=3600, must_revalidate=True)
c(headers)
self.assertEqual(headers['cache-control'],
'max-age=3600, public, must-revalidate')
c = CacheControl(maxage=3600, proxy_revalidate=True)
c(headers)
self.assertEqual(headers['cache-control'],
'max-age=3600, public, proxy-revalidate')
c = CacheControl(maxage=3600, proxy_revalidate=True,
nostore=True)
c(headers)
self.assertEqual(headers['cache-control'],
'no-store, no-cache, must-revalidate, max-age=0')
def request_start_response(self,
method,
path,
HTTP_ACCEPT=None,
headers=None,
data=None,
json=None,
content_type=None,
token=None,
oauth=None,
jwt=None,
cookie=None,
params=None,
**extra):
method = method.upper()
extra['REQUEST_METHOD'] = method.upper()
path = path or '/'
extra['HTTP_ACCEPT'] = HTTP_ACCEPT or '*/*'
extra['pulsar.connection'] = mock.MagicMock()
heads = []
if headers:
heads.extend(headers)
if json is not None:
content_type = 'application/json'
assert not data
data = json
if content_type:
heads.append(('content-type', content_type))
if token:
heads.append(('Authorization', 'Bearer %s' % token))
elif oauth:
heads.append(('Authorization', 'OAuth %s' % oauth))
elif jwt:
heads.append(('Authorization', 'JWT %s' % jwt))
if cookie:
heads.append(('Cookie', cookie))
if params:
path = full_url(path, params)
# Encode data
if (method in ENCODE_BODY_METHODS and data is not None
and not isinstance(data, bytes)):
content_type = Headers(heads).get('content-type')
if content_type is None:
data, content_type = encode_multipart_formdata(data)
heads.append(('content-type', content_type))
elif content_type == 'application/json':
data = _json.dumps(data).encode('utf-8')
request = self.app.wsgi_request(path=path,
headers=heads,
body=data,
**extra)
request.environ['SERVER_NAME'] = 'localhost'
start_response = mock.MagicMock()
return request, start_response
def __init__(self, status=None, content=None, response_headers=None,
content_type=None, encoding=None, environ=None):
self.environ = environ
self.status_code = status or self.DEFAULT_STATUS_CODE
self.encoding = encoding
self.cookies = SimpleCookie()
self.headers = Headers(response_headers, kind='server')
self.content = content
if content_type is not None:
self.content_type = content_type
def test_wsgi_environ(path=None,
method=None,
headers=None,
extra=None,
secure=False,
loop=None,
body=None):
'''An function to create a WSGI environment dictionary for testing.
:param url: the resource in the ``PATH_INFO``.
:param method: the ``REQUEST_METHOD``.
:param headers: optional request headers
:params secure: a secure connection?
:param extra: additional dictionary of parameters to add.
:return: a valid WSGI environ dictionary.
'''
parser = http_parser(kind=0)
method = (method or 'GET').upper()
path = iri_to_uri(path or '/')
request_headers = Headers(headers, kind='client')
# Add Host if not available
parsed = urlparse(path)
if 'host' not in request_headers:
if not parsed.netloc:
path = '%s%s' % ('https://:443' if secure else 'http://:80', path)
else:
request_headers['host'] = parsed.netloc
#
data = '%s %s HTTP/1.1\r\n\r\n' % (method, path)
data = data.encode('latin1')
parser.execute(data, len(data))
#
headers = Headers()
stream = StreamReader(request_headers, parser)
stream.buffer = body or b''
stream.on_message_complete.set_result(None)
extra = extra or {}
return wsgi_environ(stream, ('127.0.0.1', 8060),
'777.777.777.777:8080',
headers,
https=secure,
extra=extra)
def test_client_header(self):
h = Headers()
self.assertEqual(len(h), 0)
h['content-type'] = 'text/html'
self.assertEqual(h.get_all('content-type'), ['text/html'])
self.assertEqual(len(h), 1)
h['server'] = 'bla'
self.assertEqual(len(h), 2)
del h['content-type']
self.assertEqual(len(h), 1)
self.assertEqual(h.get_all('content-type', []), [])
def request_headers(self, environ):
'''Fill request headers from the environ dictionary and
modify them via the list of :attr:`headers_middleware`.
The returned headers will be sent to the target uri.
'''
headers = Headers(kind='client')
for k in environ:
if k.startswith('HTTP_'):
head = k[5:].replace('_', '-')
headers[head] = environ[k]
for head in ENVIRON_HEADERS:
k = head.replace('-', '_').upper()
v = environ.get(k)
if v:
headers[head] = v
return headers
def data_processed(self, response, exc=None, **kw):
'''Receive data from the requesting HTTP client.'''
status = response.get_status()
if status == '100 Continue':
stream = self.environ.get('wsgi.input') or io.BytesIO()
body = yield stream.read()
response.transport.write(body)
if response.parser.is_headers_complete():
if self._headers is None:
headers = self.remove_hop_headers(response.headers)
self._headers = Headers(headers, kind='server')
# start the response
self.start_response(status, list(self._headers))
body = response.recv_body()
if response.parser.is_message_complete():
self._done = True
self.queue.put_nowait(body)
def data_received(self, data):
'''Implements :meth:`~.ProtocolConsumer.data_received` method.
Once we have a full HTTP message, build the wsgi ``environ`` and
delegate the response to the :func:`wsgi_callable` function.
'''
p = self.parser
if p.execute(bytes(data), len(data)) == len(data):
if self._request_headers is None and p.is_headers_complete():
self._request_headers = Headers(p.get_headers(), kind='client')
stream = StreamReader(self._request_headers, p, self.transport)
self.bind_event('data_processed', stream.data_processed)
environ = self.wsgi_environ(stream)
self.event_loop. async (self._response(environ))
else:
# This is a parsing error, the client must have sent
# bogus data
raise ProtocolError
def data_received(self, data):
'''Implements :meth:`~.ProtocolConsumer.data_received` method.
Once we have a full HTTP message, build the wsgi ``environ`` and
delegate the response to the :func:`wsgi_callable` function.
'''
parser = self.parser
processed = parser.execute(data, len(data))
if parser.is_headers_complete():
if not self._body_reader:
headers = Headers(parser.get_headers(), kind='client')
self._body_reader = HttpBodyReader(headers,
parser,
self.transport,
self.cfg.stream_buffer,
loop=self._loop)
ensure_future(self._response(self.wsgi_environ()),
loop=self._loop)
body = parser.recv_body()
if body:
self._body_reader.feed_data(body)
#
if parser.is_message_complete():
#
self._body_reader.feed_eof()
if processed < len(data):
if not self._buffer:
self._buffer = data[processed:]
self.bind_event('post_request', self._new_request)
else:
self._buffer += data[processed:]
#
elif processed < len(data):
# This is a parsing error, the client must have sent
# bogus data
raise ProtocolError