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 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 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() 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() 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()))