def __call__(self, environ, start_response):
request = Request(environ)
lang = request.values.get('_lang')
if lang is None:
lang = (request.accept_languages.best or 'en').split('-')[0].lower()
if not has_language(lang):
lang = 'en'
request.translations = load_core_translations(lang)
request.translations.language = lang
response = None
if request.path == '/':
view = request.values.get('_current', 'start')
if request.values.get('_startsetup'):
response = self.start_setup(request)
elif view in self.views:
handler = self.views[view]
if handler is not None and \
request.values.get('_next'):
ctx = handler(request)
if ctx is not None:
response = self.handle_view(request, view, ctx)
if response is None:
if request.values.get('_next'):
view = self.next[view]
elif request.values.get('_prev'):
view = self.prev[view]
response = self.handle_view(request, view)
if response is None:
response = redirect('')
return response(environ, start_response)
def __call__(self, environ, start_response):
request = Request(environ)
lang = request.values.get('_lang')
if lang is None:
lang = (request.accept_languages.best or 'en').split('-')[0].lower()
if not has_language(lang):
lang = 'en'
request.translations = load_core_translations(lang)
request.translations.language = lang
response = None
if request.path == '/':
view = request.values.get('_current', 'start')
if request.values.get('_startsetup'):
response = self.start_setup(request)
elif view in self.views:
handler = self.views[view]
if handler is not None and \
request.values.get('_next'):
ctx = handler(request)
if ctx is not None:
response = self.handle_view(request, view, ctx)
if response is None:
if request.values.get('_next'):
view = self.next[view]
elif request.values.get('_prev'):
view = self.prev[view]
response = self.handle_view(request, view)
if response is None:
response = redirect('')
return response(environ, start_response)
def convert_chart_svg(self, request: Request):
vert_bar_chart_max_label = int(
request.args.get('vertBarChartMaxLabel', '10'))
chart_type = request.args.get('chartType')
if chart_type in ('bar', 'time', 'timescatter'):
svg_src = normalize_bar_chart_svg(request.get_data(),
vert_bar_chart_max_label)
else:
svg_src = normalize_wcloud_svg(request.get_data())
if request.args.get('outFormat', '') == 'png':
self._response.set_header('Content-Type', 'image/png')
return svg2png(bytestring=svg_src,
output_width=1200,
background_color='#FFFFFF')
elif request.args.get('outFormat', '') == 'png-print':
self._response.set_header('Content-Type', 'image/png')
return svg2png(bytestring=svg_src,
output_width=4961,
background_color='#FFFFFF')
elif request.args.get('outFormat', '') == 'svg':
self._response.set_header('Content-Type', 'image/svg+xml')
return svg2svg(bytestring=svg_src,
scale=5,
background_color='#FFFFFF')
elif request.args.get('outFormat', '') == 'pdf':
self._response.set_header('Content-Type', 'application/pdf')
return svg2pdf(bytestring=svg_src,
scale=5,
background_color='#FFFFFF')
else:
raise UserActionException('Invalid data format', code=422)
def __init__(self, environ, populate_request=True, shallow=False):
ResponseBase.__init__(self)
RequestBase.__init__(self, environ, populate_request, shallow)
self.href = Href(self.script_root or '/', self.charset)
self.abs_href = Href(self.url_root, self.charset)
self.headers = Headers([('Content-Type', 'text/html')])
self.response = []
self.status_code = 200
def __init__(self, environ, populate_request=True, shallow=False):
ResponseBase.__init__(self)
RequestBase.__init__(self, environ, populate_request, shallow)
self.href = Href(self.script_root or "/", self.charset)
self.abs_href = Href(self.url_root, self.charset)
self.headers = Headers([("Content-Type", "text/html")])
self.response = []
self.status_code = 200
def makeRequest(self, run, tag, host):
req = Request({})
req.args = {
'run': run,
'tag': tag,
'host': host,
}
return req
def __init__(self, *args, **kwargs):
self.context = {}
Request.__init__(self, *args, **kwargs)
# self.stream, self.form, self.files = parse_form_data(self.environ)
self.context.update(self.args.to_dict())
self.context.update(self.form.to_dict())
self.context.update(self.cookies)
self.context['request'] = self
def __init__(self, *args, **kwargs):
self.context = {}
Request.__init__(self, *args, **kwargs)
# self.stream, self.form, self.files = parse_form_data(self.environ)
self.context.update(self.args.to_dict())
self.context.update(self.form.to_dict())
self.context.update(self.cookies)
self.context['request'] = self
def __call__(self, environ, start_response):
request = Request(environ)
adapter = self.urlmap.bind_to_environ(environ)
try:
entrypoint, pvalues = adapter.match()
request.path_values = pvalues
response = entrypoint.handle_request(request)
except werkzeug.exceptions.HTTPException as e:
response = e
return response(environ, start_response)
def __init__(self, environ):
RequestBase.__init__(self, environ)
before_request_init.emit()
self.url_adapter = url_map.bind_to_environ(self.environ)
self.match_exception = None
try:
self.endpoint, self.view_arguments = self.url_adapter.match()
except HTTPException, e:
self.endpoint = self.view_arguments = None
self.match_exception = e
def wsgi_app(self, environ, start_response):
adapter = self.routes.bind_to_environ(environ)
try:
endpoint, args = adapter.match()
except HTTPException as e:
rv = e
else:
req = Request(environ)
req.view_args = args
rv = self.make_response(self.views[endpoint](req))
return rv(environ, start_response)
def _verify_request(environ) -> RFC7662:
auth_header = environ.get('HTTP_AUTHORIZATION', '')
if auth_header:
return bearer_auth(auth_header)
cookie = Request(environ).cookies.get(f"auth_{omd_site()}")
if cookie:
try:
username, session_id, cookie_hash = cookie.split(':', 2)
except ValueError:
raise MKAuthException("Invalid auth cookie.")
check_parsed_auth_cookie(UserId(username), session_id, cookie_hash)
return rfc7662_subject(username, 'cookie')
raise MKAuthException("You need to be authenticated to use the REST API.")
def test_large_file():
"""Test a largish file."""
data = "x" * (1024 * 600)
req = Request.from_values(data={"foo": (StringIO(data), "test.txt")}, method="POST")
# make sure we have a real file here, because we expect to be
# on the disk. > 1024 * 500
assert isinstance(req.files["foo"].stream, file)
def _send_with_auth(values, secret_key, url):
"""Send dictionary of JSON serializable `values` as a POST body to `url`
along with `auth_token` that's generated from `secret_key` and `values`
scheduler.auth.create_token expects a JSON serializable payload, so we send
a dictionary. On the receiving end of the POST request, the Flask view will
have access to a werkzeug.datastructures.ImmutableMultiDict. The easiest
and most surefire way to ensure that the payload sent to create_token will
be consistent on both ends is to generate an ImmutableMultiDict using the
werkzeug.Request.
"""
data = urllib.urlencode(values)
# Simulate a Flask request because that is what will be unpacked when the
# request is received on the other side
request = Request.from_values(
content_length=len(data),
input_stream=StringIO(data),
content_type='application/x-www-form-urlencoded',
method='POST')
# Add the auth_token, re-encode, and send
values['auth_token'] = create_token(secret_key, dict(request.form))
data = urllib.urlencode(values)
req = urllib2.Request(url, data)
response = urllib2.urlopen(req)
return json.loads(response.read())
def test_wrapper_support():
"""Securecookie wrapper integration"""
req = Request.from_values()
resp = Response()
c = SecureCookie.load_cookie(req, secret_key='foo')
assert c.new
c['foo'] = 42
assert c.secret_key == 'foo'
c.save_cookie(resp)
req = Request.from_values(headers={
'Cookie': 'session="%s"' % parse_cookie(resp.headers['set-cookie'])['session']
})
c2 = SecureCookie.load_cookie(req, secret_key='foo')
assert not c2.new
assert c2 == c
def __call__(self, environ, start_response):
# start_response('200 OK', [('Content-Type', 'text/plain')])
# return [b'hello world']
request = Request(environ)
text = 'hellow, %s' % (request.args.get('a', 'i love imooc'))
response = Response(text, mimetype="text/plain")
return response(environ, start_response)
def test_nonstandard_line_endings():
"""Test nonstandard line endings of multipart form data"""
for nl in "\n", "\r", "\r\n":
data = nl.join(
(
"--foo",
"Content-Disposition: form-data; name=foo",
"",
"this is just bar",
"--foo",
"Content-Disposition: form-data; name=bar",
"",
"blafasel",
"--foo--",
)
)
req = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="multipart/form-data; " "boundary=foo",
method="POST",
)
print req.form
assert req.form["foo"] == "this is just bar"
assert req.form["bar"] == "blafasel"
def application(environ, start_responseonse):
request = Request(environ)
if request.method == 'POST':
response = stats(request)
else:
response = upload_file(request)
return response(environ, start_responseonse)
def make_data_request(run, tool, host=None):
"""Creates a werkzeug.Request to pass as argument to ProfilePlugin.data_impl.
Args:
run: Front-end run name.
tool: ProfilePlugin tool, e.g., 'trace_viewer'.
host: Host that generated the profile data, e.g., 'localhost'.
Returns:
A werkzeug.Request to pass to ProfilePlugin.data_impl.
"""
req = Request({})
req.args = {'run': run, 'tag': tool}
if host:
req.args['host'] = host
return req
def _send_with_auth(values, secret_key, url):
"""Send dictionary of JSON serializable `values` as a POST body to `url`
along with `auth_token` that's generated from `secret_key` and `values`
scheduler.auth.create_token expects a JSON serializable payload, so we send
a dictionary. On the receiving end of the POST request, the Flask view will
have access to a werkzeug.datastructures.ImmutableMultiDict. The easiest
and most surefire way to ensure that the payload sent to create_token will
be consistent on both ends is to generate an ImmutableMultiDict using the
werkzeug.Request.
"""
data = urllib.urlencode(values)
# Simulate a Flask request because that is what will be unpacked when the
# request is received on the other side
request = Request.from_values(
content_length=len(data),
input_stream=StringIO(data),
content_type='application/x-www-form-urlencoded',
method='POST')
# Add the auth_token, re-encode, and send
values['auth_token'] = create_token(secret_key, dict(request.form))
data = urllib.urlencode(values)
req = urllib2.Request(url, data)
response = urllib2.urlopen(req)
return json.loads(response.read())
def __call__(self, environ, start_response):
local.application = self
request = Request(environ)
self.load_session(request)
response = None
try:
adapter = self.url_map.bind_to_environ(environ)
endpoint, vars = adapter.match()
if 'userid' not in request.session and endpoint != "general.register":
endpoint = 'general.login'
response = self.dispatch(request, adapter, endpoint, {})
response.status_code = 401
else:
response = self.dispatch(request, adapter, endpoint, vars)
except NotFound:
b = BaseController(request, adapter)
response = b.return_404()
except InternalServerError:
request.environ['wsgi.errors'].write(traceback.format_exc())
b = BaseController(request, adapter)
response = b.return_500()
except Forbidden:
b = BaseController(request, adapter)
response = b.return_403()
except HTTPException, e:
request.environ['wsgi.errors'].write(traceback.format_exc())
response = e
def dispatch(self, environ, start_response):
try:
local.request = Request(environ)
local.response = Response()
local.session = Session(local.request.cookies.get("session"))
try:
local.url_adapter = url_adapter = url_map.bind_to_environ(
environ)
try:
endpoint, params = url_adapter.match()
except NotFound:
endpoint = "notfound"
params = {}
local.endpoint = endpoint
endpoints[endpoint](**params)
except:
if self.debug:
raise
responders.error()
response = local.response
local.session.save()
local.session.set_cookie(local.response)
except:
if self.debug:
raise
response = Response("Fejlsidens fejlside.")
return response(environ, start_response)
def _application(self, environ, start_response):
request = Request(environ)
self.logger.info(request.full_path)
status_code = 200
headers = {'Content-Type': 'application/json'}
content = ''
if request.path == '/': # 接管主页，因为所有请求需要token，主页转发不能正常工作
headers = {'Content-Type': 'text/html'}
content = '<h1><a href="https://github.com/xiyaoWong/iotbot-http-transfer">iotbot http tranfer</a><h1>'
elif request.path.strip('/') == 'favicon.ico':
status_code = 301
del headers['Content-Type']
headers['location'] = 'https://cdn.jsdelivr.net/gh/xiyaowong/FileHost/transfer.png'
elif request.path.strip('/') == 'genToken': # 处理token生成请求
key = request.args.get('key')
if key == self.key:
token = self._genarate_token('ok, it\' funny.')
content = json.dumps({'token': token})
else:
content = '{"Ret":1111, "Msg":"key错误"}'
else: # 处理其他请求
# 鉴权
token = request.args.get('token') or request.headers.get('Authorization')
if not self._check_token(token): # 大胆，狗贼
content = '{"Ret":2222, "Msg":"无效的token"}'
else:
try:
resp = requests.request(
request.method,
'{}{}?{}'.format(
'http://{}:{}'.format(self.iotbot_host, self.iotbot_port),
request.path,
request.query_string.decode()),
headers=request.headers,
data=request.data,
timeout=self.timeout
)
except requests.Timeout as e:
self.logger.warning(e)
content = '{"Ret":3333, "Msg":"请求响应超时"}'
except requests.ConnectionError as e:
self.logger.exception(e)
content = '{"Ret":4444, "Msg":"连接错误"}'
except Exception as e:
self.logger.exception(e)
content = '{"Ret":5555, "Msg":"请求响应失败"}'
else:
content = resp.content
status_code = resp.status_code
headers = resp.headers
response = Response(content)
response.status = HTTP_STATUS_CODES[status_code]
response.status_code = status_code
for header_name, header_value in headers.items():
response.headers[header_name] = header_value
return response(environ, start_response)
def test_form(self):
"""Test for modifying existing entity with ModelForm."""
# first create a new entity
f = TestModelForm()
params = {"number": "12", "data_field": "data string",
"is_active": "False", "string_list_field": "list"}
self.assertEqual(f.validate(params), True)
f.save()
self.assertEqual(TestModel.all().count(), 1)
entity = TestModel.all().get()
self.assertEqual(entity.number, 12)
# modify with TestModelForm
f = TestModelForm(instance=entity)
params = {"number": "13", "data_field": "modified data",
"is_active": "True", "string_list_field": "line 1\nline 2"}
self.assertEqual(f.validate(params), True)
f.save()
# check values
self.assertEqual(TestModel.all().count(), 1)
entity = TestModel.all().get()
self.assertEqual(entity.number, 13)
self.assertEqual(entity.data_field, "modified data")
self.assertEqual(entity.is_active, True)
self.assertEqual(entity.string_list_field, ["line 1", "line 2"])
"""Form validation test with ModelForm."""
os.environ['REQUEST_METHOD'] = 'POST'
local.request = Request(get_env())
f = TestModelForm()
params = {"number": "12"}
# In your view, you can validate the form data with:
# f.validate(request.form)
# or with(If you have FileField):
# f.validate(request.form, request.files)
self.assertEqual(f.validate(params), False)
f.reset()
params = {"number": "12",
"data_field": "data string longer than 20 characters",
"is_active": "False",
"string_list_field": "test"}
self.assertEqual(f.validate(params), False)
f.reset()
params = {"number": "12",
"data_field": "data string",
"is_active": "False",
"string_list_field": ""}
self.assertEqual(f.validate(params), False)
# create a new entity
f.reset()
params = {"number": "12", "data_field": "data string",
"is_active": "False", "string_list_field": "list"}
self.assertEqual(f.validate(params), True)
f.save()
self.assertEqual(TestModel.all().count(), 2)
def __call__(self, environ, start_response):
request = Request(environ)
urls = self.url_map.bind_to_environ(environ)
try:
endpoint, args = urls.match()
except NotFound, exc:
args = {}
endpoint = '/'
def __call__(self, environ, start_response):
request = Request(environ)
auth = request.authorization
if not auth or not self.check_auth(auth.username, auth.password):
response = self.auth_required(request)
else:
response = self.dispatch_request(request)
return response(environ, start_response)
def test_large_file():
"""Test a largish file."""
data = 'x' * (1024 * 600)
req = Request.from_values(data={'foo': (StringIO(data), 'test.txt')},
method='POST')
# make sure we have a real file here, because we expect to be
# on the disk. > 1024 * 500
assert isinstance(req.files['foo'].stream, file)
def _create_request(*, path_info: str = "/path") -> Request:
return Request({
"wsgi.url_scheme": "https",
"SERVER_NAME": "example.com",
"SERVER_PORT": "443",
"SCRIPT_NAME": "/base/",
"PATH_INFO": path_info,
})
def test_large_file():
"""Test a largish file."""
data = 'x' * (1024 * 600)
req = Request.from_values(data={'foo': (StringIO(data), 'test.txt')},
method='POST')
# make sure we have a real file here, because we expect to be
# on the disk. > 1024 * 500
assert isinstance(req.files['foo'].stream, file)
def dispatch_request(self, environ, start_response):
self.bind_to_context()
local.request = request = Request(environ, start_response)
local.url_adapter = adapter = url_map.bind_to_environ(environ)
try:
endpoint, values = adapter.match(request.path)
response = endpoints[endpoint](request, **values)
except HTTPException, e:
response = e
def __call__(self, environ, start_response):
request = Request(environ)
urls = self.url_map.bind_to_environ(environ)
try:
endpoint, args = urls.match()
except NotFound, exc:
# Convert unknown /path/names into endpoints named path_names
endpoint = request.path.lstrip('/').replace('/', '_')
args = {}
def test_digest_challenge_response():
request = Request(environ={'REMOTE_ADDR': "example.com"})
result = digest_challenge_response(request, None, None)
assert '''qop="auth, auth-int"''' in result.headers["WWW-Authenticate"]
assert '''algorithm=''' not in result.headers["WWW-Authenticate"]
result = digest_challenge_response(request, "flibble", "flamble")
assert '''qop="flibble"''' in result.headers["WWW-Authenticate"]
assert '''algorithm=flamble''' in result.headers["WWW-Authenticate"]
def __call__(self, environ, start_response):
request = Request(environ)
method = request.args.get('METHOD', '').upper()
if method in self.allowed_methods:
method = method.encode('ascii', 'replace')
environ['REQUEST_METHOD'] = method
if method in self.bodyless_methods:
environ['CONTENT_LENGTH'] = 0
return self.app(environ, start_response)
def __init__(self, environ):
RequestBase.__init__(self, environ)
before_request_init.emit()
self.url_adapter = url_map.bind_to_environ(self.environ)
self.view_lang = self.match_exception = None
try:
self.endpoint, self.view_arguments = self.url_adapter.match()
view_lang = self.view_arguments.pop('lang_code', None)
if view_lang is not None:
try:
self.view_lang = Locale.parse(view_lang)
if not has_section(self.view_lang):
raise UnknownLocaleError(str(self.view_lang))
except UnknownLocaleError:
self.view_lang = None
self.match_exception = NotFound()
except HTTPException, e:
self.endpoint = self.view_arguments = None
self.match_exception = e
def __call__(self, environ, start_response):
request = Request(environ)
if self.input_name in request.form:
method = request.form[self.input_name].upper()
if method in ['GET', 'POST', 'PUT', 'DELETE']:
environ['REQUEST_METHOD'] = method
return self.app(environ, start_response)
def dispatch(self, environ, start_response):
local.application = self
request = Request(environ)
local.url_adapter = adapter = url_map.bind_to_environ(environ)
request.debug = self.debug
request.session = SecureCookie.load_cookie(request,
key='com.kinaj.session',
secret_key='kinaj')
try:
endpoint, values = adapter.match()
handler = getattr(views, endpoint)
response = handler(request, **values)
except NotFound, e:
response = views.not_found(request)
response.status_code = 404
def __init__(self, environ):
RequestBase.__init__(self, environ)
before_request_init.emit()
self.url_adapter = url_map.bind_to_environ(self.environ)
self.view_lang = self.match_exception = None
try:
self.endpoint, self.view_arguments = self.url_adapter.match()
view_lang = self.view_arguments.pop('lang_code', None)
if view_lang is not None:
try:
self.view_lang = Locale.parse(view_lang)
if not has_section(self.view_lang):
raise UnknownLocaleError(str(self.view_lang))
except UnknownLocaleError:
self.view_lang = None
self.match_exception = NotFound()
except HTTPException, e:
self.endpoint = self.view_arguments = None
self.match_exception = e
def __call__(self, environ, start_response):
request = None
try:
request = Request(environ, self.mapping)
response = self.dispatch(request)
return response(environ, start_response)
except RequestRedirect as e:
return Response(status=e.code, headers={'Location': e.new_url})(environ, start_response)
except Exception as e:
return self.error_handler(e, request)(environ, start_response)
def __call__(self, environ, start_response):
request = Request(environ)
if request.method == 'GET':
log.debug('No CSRF check for GET')
else:
if 'CsrfCheck' in request.headers:
log.debug('Found CsrfCheck')
else:
log.error(f'No CsrfCheck header for {request.method}')
raise BadRequest()
return self.app(environ, start_response)
def dispatch(self, environ, start_response):
local.application = self
request = Request(environ)
local.url_adapter = adapter = url_map.bind_to_environ(environ)
try:
endpoint, values = adapter.match()
handler = getattr(views, endpoint)
response = handler(request, **values)
except NotFound, e:
response = views.not_found(request)
response.status_code = 404
def dispatch(self, environ, start_response):
local.application = self
request = Request(environ)
local.url_adapter = adapter = url_map.bind_to_environ(environ)
try:
endpoint, values = adapter.match()
endpoint, module = endpoint.split(' ')
handler = getattr(views, endpoint)
response = handler(request, **values)
except HTTPException, e:
response = e
def test_extra_newline_multipart():
"""Test for multipart uploads with extra newlines"""
# this test looks innocent but it was actually timeing out in
# the Werkzeug 0.5 release version (#394)
data = "\r\n\r\n--foo\r\n" 'Content-Disposition: form-data; name="foo"\r\n\r\n' "a string\r\n" "--foo--"
data = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="multipart/form-data; boundary=foo",
method="POST",
)
assert not data.files
assert data.form["foo"] == "a string"
def dispatch(self, environ, start_response):
local.application = self
request = Request(environ)
## this is where we load the cookie if any, or create a new one
sid = request.cookies.get('kif415-helfer-login')
if sid is None:
request.session = session_store.new()
else:
request.session = session_store.get(sid)
if not validate_session(request.session):
session_store.delete(request.session)
request.session = session_store.new()
request.session['logout'] = True
local.url_adapter = adapter = url_map.bind_to_environ(environ)
try:
endpoint, values = adapter.match()
handler = getattr(views, endpoint)
response = handler(request, **values)
except HTTPException, e:
response = e # XXX hrm? this breaks when setting cookies!
def test_multipart_file_no_content_type():
"""Chrome does not always provide a content type."""
data = (
'--foo\r\n'
'Content-Disposition: form-data; name="test"; filename="test.txt"\r\n\r\n'
'file contents\r\n--foo--'
)
data = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='multipart/form-data; boundary=foo',
method='POST')
assert data.files['test'].filename == 'test.txt'
assert data.files['test'].read() == 'file contents'
def test_multipart_file_no_content_type():
"""Chrome does not always provide a content type."""
data = (
"--foo\r\n"
'Content-Disposition: form-data; name="test"; filename="test.txt"\r\n\r\n'
"file contents\r\n--foo--"
)
data = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="multipart/form-data; boundary=foo",
method="POST",
)
assert data.files["test"].filename == "test.txt"
assert data.files["test"].read() == "file contents"
def test_multipart_headers():
"""Test access to multipart headers"""
data = ('--foo\r\n'
'Content-Disposition: form-data; name="foo"; filename="foo.txt"\r\n'
'X-Custom-Header: blah\r\n'
'Content-Type: text/plain; charset=utf-8\r\n\r\n'
'file contents, just the contents\r\n'
'--foo--')
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='multipart/form-data; boundary=foo',
method='POST')
foo = req.files['foo']
assert foo.content_type == 'text/plain'
assert foo.headers['content-type'] == 'text/plain; charset=utf-8'
assert foo.headers['x-custom-header'] == 'blah'
def test_end_of_file_multipart():
"""Test for multipart files ending unexpectedly"""
# This test looks innocent but it was actually timeing out in
# the Werkzeug 0.5 release version (#394)
data = (
'--foo\r\n'
'Content-Disposition: form-data; name="test"; filename="test.txt"\r\n'
'Content-Type: text/plain\r\n\r\n'
'file contents and no end'
)
data = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='multipart/form-data; boundary=foo',
method='POST')
assert not data.files
assert not data.form
def serve(self, interface='0.0.0.0', port=3080,
max_size=DEFAULT_MAX_CONC_REQUESTS):
self.log.info('ZenQueue HTTP Server v%s', zenqueue.__version__)
if interface == '0.0.0.0':
self.log.info('Serving on %s:%d (all interfaces)', interface, port)
else:
self.log.info('Serving on %s:%d', interface, port)
self.sock = api.tcp_listener((interface, port))
try:
# Wrap `self` with `Request.application` so that we get a request as
# an argument instead of the usual `environ, start_response`.
wsgi.server(self.sock, Request.application(self), max_size=max_size)
finally:
self.sock = None
def test_multipart_headers():
"""Test access to multipart headers"""
data = (
"--foo\r\n"
'Content-Disposition: form-data; name="foo"; filename="foo.txt"\r\n'
"X-Custom-Header: blah\r\n"
"Content-Type: text/plain; charset=utf-8\r\n\r\n"
"file contents, just the contents\r\n"
"--foo--"
)
req = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="multipart/form-data; boundary=foo",
method="POST",
)
foo = req.files["foo"]
assert foo.content_type == "text/plain"
assert foo.headers["content-type"] == "text/plain; charset=utf-8"
assert foo.headers["x-custom-header"] == "blah"
def test_wrapper_internals():
"""Test internals of the wrappers"""
from werkzeug import Request
req = Request.from_values(data={'foo': 'bar'}, method='POST')
req._load_form_data()
assert req.form.to_dict() == {'foo': 'bar'}
# second call does not break
req._load_form_data()
assert req.form.to_dict() == {'foo': 'bar'}
# check reprs
assert repr(req) == "<Request 'http://localhost/' [POST]>"
resp = Response()
assert repr(resp) == '<Response 0 bytes [200 OK]>'
resp.data = 'Hello World!'
assert repr(resp) == '<Response 12 bytes [200 OK]>'
resp.response = iter(['Test'])
assert repr(resp) == '<Response streamed [200 OK]>'
# unicode data does not set content length
response = Response([u'Hällo Wörld'])
headers = response.get_wsgi_headers(create_environ())
assert 'Content-Length' not in headers
response = Response(['Hällo Wörld'])
headers = response.get_wsgi_headers(create_environ())
assert 'Content-Length' in headers
# check for internal warnings
print 'start'
filterwarnings('error', category=Warning)
response = Response()
environ = create_environ()
response.response = 'What the...?'
assert_raises(Warning, lambda: list(response.iter_encoded()))
assert_raises(Warning, lambda: list(response.get_app_iter(environ)))
response.direct_passthrough = True
assert_raises(Warning, lambda: list(response.iter_encoded()))
assert_raises(Warning, lambda: list(response.get_app_iter(environ)))
resetwarnings()
def test_nonstandard_line_endings():
"""Test nonstandard line endings of multipart form data"""
for nl in '\n', '\r', '\r\n':
data = nl.join((
'--foo',
'Content-Disposition: form-data; name=foo',
'',
'this is just bar',
'--foo',
'Content-Disposition: form-data; name=bar',
'',
'blafasel',
'--foo--'
))
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='multipart/form-data; '
'boundary=foo', method='POST')
print req.form
assert req.form['foo'] == 'this is just bar'
assert req.form['bar'] == 'blafasel'
def __init__(self, environ):
WerkzeugRequest.__init__(self, environ)
LoggerMixin.__init__(self)
local.request = self
def makeRequest(self, run, tag, host):
req = Request({})
req.args = {'run': run, 'tag': tag, 'host': host,}
return req
def __init__(self, environ):
RequestBase.__init__(self, environ)
self.endpoint = None
self.view_args = None
def test_limiting():
"""Test the limiting features"""
data = "foo=Hello+World&bar=baz"
req = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="application/x-www-form-urlencoded",
method="POST",
)
req.max_content_length = 400
assert req.form["foo"] == "Hello World"
req = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="application/x-www-form-urlencoded",
method="POST",
)
req.max_form_memory_size = 7
assert_raises(RequestEntityTooLarge, lambda: req.form["foo"])
req = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="application/x-www-form-urlencoded",
method="POST",
)
req.max_form_memory_size = 400
assert req.form["foo"] == "Hello World"
data = (
"--foo\r\nContent-Disposition: form-field; name=foo\r\n\r\n"
"Hello World\r\n"
"--foo\r\nContent-Disposition: form-field; name=bar\r\n\r\n"
"bar=baz\r\n--foo--"
)
req = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="multipart/form-data; boundary=foo",
method="POST",
)
req.max_content_length = 4
assert_raises(RequestEntityTooLarge, lambda: req.form["foo"])
req = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="multipart/form-data; boundary=foo",
method="POST",
)
req.max_content_length = 400
assert req.form["foo"] == "Hello World"
req = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="multipart/form-data; boundary=foo",
method="POST",
)
req.max_form_memory_size = 7
assert_raises(RequestEntityTooLarge, lambda: req.form["foo"])
req = Request.from_values(
input_stream=StringIO(data),
content_length=len(data),
content_type="multipart/form-data; boundary=foo",
method="POST",
)
req.max_form_memory_size = 400
assert req.form["foo"] == "Hello World"
def __init__(self, *args, **kwargs):
BaseRequest.__init__(self, *args, **kwargs)
#: Logged database queries
self.queries = []
def __init__(self, map_adapter, *args, **kwargs):
MapAdapterMixin.__init__(self, map_adapter)
WerkzeugRequest.__init__(self, *args, **kwargs)
def test_limiting():
"""Test the limiting features"""
data = 'foo=Hello+World&bar=baz'
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='application/x-www-form-urlencoded',
method='POST')
req.max_content_length = 4
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='application/x-www-form-urlencoded',
method='POST')
req.max_content_length = 400
assert req.form['foo'] == 'Hello World'
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='application/x-www-form-urlencoded',
method='POST')
req.max_form_memory_size = 7
assert_raises(RequestEntityTooLarge, lambda: req.form['foo'])
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='application/x-www-form-urlencoded',
method='POST')
req.max_form_memory_size = 400
assert req.form['foo'] == 'Hello World'
data = ('--foo\r\nContent-Disposition: form-field; name=foo\r\n\r\n'
'Hello World\r\n'
'--foo\r\nContent-Disposition: form-field; name=bar\r\n\r\n'
'bar=baz\r\n--foo--')
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='multipart/form-data; boundary=foo',
method='POST')
req.max_content_length = 4
assert_raises(RequestEntityTooLarge, lambda: req.form['foo'])
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='multipart/form-data; boundary=foo',
method='POST')
req.max_content_length = 400
assert req.form['foo'] == 'Hello World'
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='multipart/form-data; boundary=foo',
method='POST')
req.max_form_memory_size = 7
assert_raises(RequestEntityTooLarge, lambda: req.form['foo'])
req = Request.from_values(input_stream=StringIO(data),
content_length=len(data),
content_type='multipart/form-data; boundary=foo',
method='POST')
req.max_form_memory_size = 400
assert req.form['foo'] == 'Hello World'
def __init__(self, app, environ):
wzRequest.__init__(self, environ)
self.app = app
