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