def test_unsupported_media_type(self):
"Test various Content-* combinations."
class ReadOnlyResource(Resource):
def post(self, request, response, *args, **kwargs):
response.status = codes.no_content
resource = ReadOnlyResource()
self.params["method"] = "POST"
# Works..
self.params["content_type"] = "application/json; charset=utf-8"
self.params["data"] = '{"message": "hello world"}'
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 204)
# Unsupported Media Type
self.params["content_type"] = "application/xml"
self.params["data"] = "<message>hello world</message>"
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 415)
def test_default(self):
"Tests for the default Resource which is very limited."
resource = Resource()
self.params["method"] = "OPTIONS"
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 200)
# Try another non-default method
self.params["method"] = "GET"
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 405)
self.assertEqual(response.headers["allow"], "OPTIONS")
class PatchResource(Resource):
allowed_methods = ("PATCH", "OPTIONS")
def patch(self, request, response):
response.status = codes.no_content
resource = PatchResource()
self.params["method"] = "OPTIONS"
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["Accept-Patch"], "application/json")
def test_request_entity_too_large(self):
"Test request entity too large."
class TinyResource(Resource):
max_request_entity_length = 20
def post(self, request, response, *args, **kwargs):
response.status = codes.no_content
resource = TinyResource()
self.params["method"] = "POST"
self.params["content_type"] = "application/json"
self.params["data"] = '{"message": "hello"}'
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 204)
self.params["data"] = '{"message": "hello world"}'
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 413)
def test_not_acceptable(self):
"Test various Accept-* combinations."
class ReadOnlyResource(Resource):
def get(self, request, response, *args, **kwargs):
return "{}"
resource = ReadOnlyResource()
# Non-explicit
self.params["method"] = "GET"
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 200)
self.params["headers"] = {"Accept": "application/json,application/xml;q=0.9,*/*;q=0.8"}
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 200)
self.params["headers"] = {"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"}
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 406)
self.params["headers"] = {"Accept": "*/*"}
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 406)
def from_values(cls, *args, **kwargs):
"""Create a new request object based on the values provided. If
environ is given missing values are filled from there. This method is
useful for small scripts when you need to simulate a request from an URL.
Do not use this method for unittesting, there is a full featured client
object (:class:`Client`) that allows to create multipart requests,
support for cookies etc.
This accepts the same options as the
:class:`~werkzeug.test.EnvironBuilder`.
.. versionchanged:: 0.5
This method now accepts the same arguments as
:class:`~werkzeug.test.EnvironBuilder`. Because of this the
`environ` parameter is now called `environ_overrides`.
:return: request object
"""
from werkzeug.test import EnvironBuilder
charset = kwargs.pop('charset', cls.charset)
kwargs['charset'] = charset
builder = EnvironBuilder(*args, **kwargs)
try:
return builder.get_request(cls)
finally:
builder.close()
def from_values(cls, *args, **kwargs):
"""Create a new request object based on the values provided. If
environ is given missing values are filled from there. This method is
useful for small scripts when you need to simulate a request from an URL.
Do not use this method for unittesting, there is a full featured client
object (:class:`Client`) that allows to create multipart requests,
support for cookies etc.
This accepts the same options as the
:class:`~werkzeug.test.EnvironBuilder`.
.. versionchanged:: 0.5
This method now accepts the same arguments as
:class:`~werkzeug.test.EnvironBuilder`. Because of this the
`environ` parameter is now called `environ_overrides`.
:return: request object
"""
from werkzeug.test import EnvironBuilder
charset = kwargs.pop('charset', cls.charset)
kwargs['charset'] = charset
builder = EnvironBuilder(*args, **kwargs)
try:
return builder.get_request(cls)
finally:
builder.close()
def test_auth_object():
builder = EnvironBuilder(auth=Authorization("digest", {
"username": "******",
"password": "******"
}))
request = builder.get_request()
assert request.headers["Authorization"].startswith("Digest ")
def from_values(cls, *args, **kwargs):
from werkzeug.test import EnvironBuilder
charset = kwargs.pop('charset', cls.charset)
builder = EnvironBuilder(*args, **kwargs)
try:
return builder.get_request(cls)
finally:
builder.close()
def from_values(cls, *args, **kwargs):
from werkzeug.test import EnvironBuilder
charset = kwargs.pop('charset', cls.charset)
builder = EnvironBuilder(*args, **kwargs)
try:
return builder.get_request(cls)
finally:
builder.close()
def test_request (self, * args, ** kw) :
"""Return a request object corresponding to `args` and `kw`. All
arguments supported by `werkzeug.test.EnvironBuilder` plus
`request_class` are allowed.
"""
request_class = kw.pop ("request_class", self.root.Request)
env_builder = EnvironBuilder (* args, ** kw)
return env_builder.get_request (request_class)
def test_response_with_none_without_etag():
class GETTest(RESTController):
pass
controller = GETTest(App)
env = EnvironBuilder(
headers=[('If-None-Match', '"56"')])
with pytest.raises(TypeError):
controller.response(env.get_request(), None)
def test_response_with_none_and_etag():
class GETTest(RESTController):
pass
controller = GETTest(App)
env = EnvironBuilder(
headers=[('If-None-Match', '"56"')])
response = controller.response(env.get_request(), None, etag='56')
assert response.status_code == 304
assert response.headers['ETag'] == '"56"'
def test_rate_limit(self):
"""Test a global rate limiting implementation.
This test will take 3 seconds to run to mimic request handling over
time.
"""
import time
from datetime import datetime
class RateLimitResource(Resource):
rate_limit_count = 10
rate_limit_seconds = 2
# Keep track of requests globally for the resource.. only for test
# purposes, not thread-safe
request_frame_start = datetime.now()
request_count = 0
def check_too_many_requests(self, request, response, *args, **kwargs):
interval = (datetime.now() - self.request_frame_start).seconds
self.request_count += 1
# Reset frame if the interval is greater than the rate limit seconds,
# i.e on the 3 second in this test
if interval > self.rate_limit_seconds:
self.request_frame_start = datetime.now()
self.request_count = 1
# Throttle
elif self.request_count > self.rate_limit_count and interval <= self.rate_limit_seconds:
return True
return False
resource = RateLimitResource()
self.params["method"] = "OPTIONS"
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
for _ in xrange(0, 10):
response = resource(request)
self.assertEqual(response.status_code, 200)
time.sleep(1)
for _ in xrange(0, 10):
response = resource(request)
self.assertEqual(response.status_code, 429)
time.sleep(2)
for _ in xrange(0, 10):
response = resource(request)
self.assertEqual(response.status_code, 200)
def test_environ_builder_content_type(self):
builder = EnvironBuilder()
self.assert_is_none(builder.content_type)
builder.method = 'POST'
self.assert_equal(builder.content_type, 'application/x-www-form-urlencoded')
builder.form['foo'] = 'bar'
self.assert_equal(builder.content_type, 'application/x-www-form-urlencoded')
builder.files.add_file('blafasel', BytesIO(b'foo'), 'test.txt')
self.assert_equal(builder.content_type, 'multipart/form-data')
req = builder.get_request()
self.assert_strict_equal(req.form['foo'], u'bar')
self.assert_strict_equal(req.files['blafasel'].read(), b'foo')
def test_environ_builder_content_type():
builder = EnvironBuilder()
assert builder.content_type is None
builder.method = "POST"
assert builder.content_type == "application/x-www-form-urlencoded"
builder.form["foo"] = "bar"
assert builder.content_type == "application/x-www-form-urlencoded"
builder.files.add_file("blafasel", BytesIO(b"foo"), "test.txt")
assert builder.content_type == "multipart/form-data"
req = builder.get_request()
strict_eq(req.form["foo"], u"bar")
strict_eq(req.files["blafasel"].read(), b"foo")
def test_environ_builder_content_type(self):
builder = EnvironBuilder()
self.assert_is_none(builder.content_type)
builder.method = 'POST'
self.assert_equal(builder.content_type, 'application/x-www-form-urlencoded')
builder.form['foo'] = 'bar'
self.assert_equal(builder.content_type, 'application/x-www-form-urlencoded')
builder.files.add_file('blafasel', BytesIO(b'foo'), 'test.txt')
self.assert_equal(builder.content_type, 'multipart/form-data')
req = builder.get_request()
self.assert_strict_equal(req.form['foo'], u'bar')
self.assert_strict_equal(req.files['blafasel'].read(), b'foo')
def test_environ_builder_content_type(self):
builder = EnvironBuilder()
assert builder.content_type is None
builder.method = 'POST'
assert builder.content_type == 'application/x-www-form-urlencoded'
builder.form['foo'] = 'bar'
assert builder.content_type == 'application/x-www-form-urlencoded'
builder.files.add_file('blafasel', StringIO('foo'), 'test.txt')
assert builder.content_type == 'multipart/form-data'
req = builder.get_request()
assert req.form['foo'] == 'bar'
assert req.files['blafasel'].read() == 'foo'
def test_get_with_matching_etag():
class GETTest(RESTController):
def get(self, request, id):
return {'test': 'testing'}
controller = GETTest(App)
env = EnvironBuilder(
headers=[('If-None-Match', '"56765472680401499c79732468ba4340"')])
response = controller.dispatch(env.get_request(), 'id')
assert response.status_code == 304
assert response.headers['ETag'] == '"56765472680401499c79732468ba4340"'
assert response.headers['Cache-Control'] == 'must-revalidate'
assert response.response == []
def test_service_unavailable(self):
"Test service availability."
class IndefiniteUnavailableResource(Resource):
unavailable = True
resource = IndefiniteUnavailableResource()
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 503)
self.assertTrue("retry-after" not in response.headers)
class DeltaUnavailableResource(Resource):
unavailable = 20
resource = DeltaUnavailableResource()
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 503)
self.assertEqual(response.headers["retry-after"], 20)
from datetime import datetime, timedelta
from werkzeug.http import http_date
future = datetime.now() + timedelta(seconds=20)
class DatetimeUnavailableResource(Resource):
unavailable = future
resource = DatetimeUnavailableResource()
environ = EnvironBuilder(**self.params)
request = environ.get_request(cls=Request)
response = resource(request)
self.assertEqual(response.status_code, 503)
self.assertEqual(response.headers["retry-after"], http_date(future))
def test_environ_builder_basics():
b = EnvironBuilder()
assert b.content_type is None
b.method = "POST"
assert b.content_type == "application/x-www-form-urlencoded"
b.files.add_file("test", BytesIO(b"test contents"), "test.txt")
assert b.files["test"].content_type == "text/plain"
assert b.content_type == "multipart/form-data"
b.form["test"] = "normal value"
req = b.get_request()
b.close()
strict_eq(req.url, u"http://localhost/")
strict_eq(req.method, "POST")
strict_eq(req.form["test"], u"normal value")
assert req.files["test"].content_type == "text/plain"
strict_eq(req.files["test"].filename, u"test.txt")
strict_eq(req.files["test"].read(), b"test contents")
def test_environ_builder_basics(self):
b = EnvironBuilder()
self.assert_is_none(b.content_type)
b.method = 'POST'
self.assert_equal(b.content_type, 'application/x-www-form-urlencoded')
b.files.add_file('test', BytesIO(b'test contents'), 'test.txt')
self.assert_equal(b.files['test'].content_type, 'text/plain')
self.assert_equal(b.content_type, 'multipart/form-data')
b.form['test'] = 'normal value'
req = b.get_request()
b.close()
self.assert_strict_equal(req.url, u'http://localhost/')
self.assert_strict_equal(req.method, 'POST')
self.assert_strict_equal(req.form['test'], u'normal value')
self.assert_equal(req.files['test'].content_type, 'text/plain')
self.assert_strict_equal(req.files['test'].filename, u'test.txt')
self.assert_strict_equal(req.files['test'].read(), b'test contents')
def test_environ_builder_basics():
b = EnvironBuilder()
assert b.content_type is None
b.method = 'POST'
assert b.content_type == 'application/x-www-form-urlencoded'
b.files.add_file('test', BytesIO(b'test contents'), 'test.txt')
assert b.files['test'].content_type == 'text/plain'
assert b.content_type == 'multipart/form-data'
b.form['test'] = 'normal value'
req = b.get_request()
b.close()
strict_eq(req.url, u'http://localhost/')
strict_eq(req.method, 'POST')
strict_eq(req.form['test'], u'normal value')
assert req.files['test'].content_type == 'text/plain'
strict_eq(req.files['test'].filename, u'test.txt')
strict_eq(req.files['test'].read(), b'test contents')
def test_environ_builder_basics(self):
b = EnvironBuilder()
self.assert_is_none(b.content_type)
b.method = 'POST'
self.assert_equal(b.content_type, 'application/x-www-form-urlencoded')
b.files.add_file('test', BytesIO(b'test contents'), 'test.txt')
self.assert_equal(b.files['test'].content_type, 'text/plain')
self.assert_equal(b.content_type, 'multipart/form-data')
b.form['test'] = 'normal value'
req = b.get_request()
b.close()
self.assert_strict_equal(req.url, u'http://localhost/')
self.assert_strict_equal(req.method, 'POST')
self.assert_strict_equal(req.form['test'], u'normal value')
self.assert_equal(req.files['test'].content_type, 'text/plain')
self.assert_strict_equal(req.files['test'].filename, u'test.txt')
self.assert_strict_equal(req.files['test'].read(), b'test contents')
def test_environ_builder_basics(self):
b = EnvironBuilder()
assert b.content_type is None
b.method = 'POST'
assert b.content_type == 'application/x-www-form-urlencoded'
b.files.add_file('test', StringIO('test contents'), 'test.txt')
assert b.files['test'].content_type == 'text/plain'
assert b.content_type == 'multipart/form-data'
b.form['test'] = 'normal value'
req = b.get_request()
b.close()
assert req.url == 'http://localhost/'
assert req.method == 'POST'
assert req.form['test'] == 'normal value'
assert req.files['test'].content_type == 'text/plain'
assert req.files['test'].filename == 'test.txt'
assert req.files['test'].read() == 'test contents'
def test_environ_builder_content_type():
builder = EnvironBuilder()
assert builder.content_type is None
builder.method = "POST"
assert builder.content_type is None
builder.method = "PUT"
assert builder.content_type is None
builder.method = "PATCH"
assert builder.content_type is None
builder.method = "DELETE"
assert builder.content_type is None
builder.method = "GET"
assert builder.content_type is None
builder.form["foo"] = "bar"
assert builder.content_type == "application/x-www-form-urlencoded"
builder.files.add_file("blafasel", BytesIO(b"foo"), "test.txt")
assert builder.content_type == "multipart/form-data"
req = builder.get_request()
assert req.form["foo"] == "bar"
assert req.files["blafasel"].read() == b"foo"
def test_environ_builder_content_type():
builder = EnvironBuilder()
assert builder.content_type is None
builder.method = 'POST'
assert builder.content_type is None
builder.method = 'PUT'
assert builder.content_type is None
builder.method = 'PATCH'
assert builder.content_type is None
builder.method = 'DELETE'
assert builder.content_type is None
builder.method = 'GET'
assert builder.content_type is None
builder.form['foo'] = 'bar'
assert builder.content_type == 'application/x-www-form-urlencoded'
builder.files.add_file('blafasel', BytesIO(b'foo'), 'test.txt')
assert builder.content_type == 'multipart/form-data'
req = builder.get_request()
strict_eq(req.form['foo'], u'bar')
strict_eq(req.files['blafasel'].read(), b'foo')
def test_environ_builder_content_type():
builder = EnvironBuilder()
assert builder.content_type is None
builder.method = 'POST'
assert builder.content_type is None
builder.method = 'PUT'
assert builder.content_type is None
builder.method = 'PATCH'
assert builder.content_type is None
builder.method = 'DELETE'
assert builder.content_type is None
builder.method = 'GET'
assert builder.content_type == None
builder.form['foo'] = 'bar'
assert builder.content_type == 'application/x-www-form-urlencoded'
builder.files.add_file('blafasel', BytesIO(b'foo'), 'test.txt')
assert builder.content_type == 'multipart/form-data'
req = builder.get_request()
strict_eq(req.form['foo'], u'bar')
strict_eq(req.files['blafasel'].read(), b'foo')
def test_environ_builder_basics():
b = EnvironBuilder()
assert b.content_type is None
b.method = 'POST'
assert b.content_type is None
b.form['test'] = 'normal value'
assert b.content_type == 'application/x-www-form-urlencoded'
b.files.add_file('test', BytesIO(b'test contents'), 'test.txt')
assert b.files['test'].content_type == 'text/plain'
assert b.content_type == 'multipart/form-data'
req = b.get_request()
b.close()
strict_eq(req.url, u'http://localhost/')
strict_eq(req.method, 'POST')
strict_eq(req.form['test'], u'normal value')
assert req.files['test'].content_type == 'text/plain'
strict_eq(req.files['test'].filename, u'test.txt')
strict_eq(req.files['test'].read(), b'test contents')
def test_environ_builder_basics():
b = EnvironBuilder()
assert b.content_type is None
b.method = "POST"
assert b.content_type is None
b.form["test"] = "normal value"
assert b.content_type == "application/x-www-form-urlencoded"
b.files.add_file("test", BytesIO(b"test contents"), "test.txt")
assert b.files["test"].content_type == "text/plain"
b.form["test_int"] = 1
assert b.content_type == "multipart/form-data"
req = b.get_request()
b.close()
assert req.url == "http://localhost/"
assert req.method == "POST"
assert req.form["test"] == "normal value"
assert req.files["test"].content_type == "text/plain"
assert req.files["test"].filename == "test.txt"
assert req.files["test"].read() == b"test contents"
def test_basic_auth_miss(self):
eb = EnvironBuilder(headers={"Authorization": "Notbasic"})
m = BasicAuthMethod(eb.get_request())
m.check() |should_be.equal_to| False
def test_basic_auth():
builder = EnvironBuilder(auth=("username", "password"))
request = builder.get_request()
auth = parse_authorization_header(request.headers["Authorization"])
assert auth.username == "username"
assert auth.password == "password"
def test_basic_auth_valid(self):
eb = EnvironBuilder(headers={"Authorization": "Basic "+b64encode("usr:pwd")})
m = BasicAuthMethod(eb.get_request())
m.check() |should_be.equal_to| True
m.get_user(t.FakeAuthBackend()) |should_be.equal_to| {"username": "******", "password": "******"}
def test_basic_auth_invalid(self):
eb = EnvironBuilder(headers={"Authorization": "Basic notbase64"})
m = BasicAuthMethod(eb.get_request())
m.check() |should_be.equal_to| True
InvalidAuthException |should_be.thrown_by| (lambda: m.get_user(t.FakeAuthBackend()))
