Python EnvironBuilder.get_request方法代码示例

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
    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)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
    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)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
    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")

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
    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)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
    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()

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
 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()

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
 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)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
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)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
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"'

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
    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)

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
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")

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
 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'

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
 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')

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
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 == []

# 需要导入模块: from werkzeug.test import EnvironBuilder [as 别名]
# 或者: from werkzeug.test.EnvironBuilder import get_request [as 别名]
    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))