Python SimpleCookie.update方法代码示例

# 需要导入模块: from Cookie import SimpleCookie [as 别名]
# 或者: from Cookie.SimpleCookie import update [as 别名]
class TestClient(object):

    def __init__(self):
        self.cookies = SimpleCookie()

    def get_request(self, path, method="GET", body=None,
                    **extra):
        env = StubWSGIRequest(path)
        env['REQUEST_METHOD'] = method
        env['wsgi.input'] = StringIO(body)
        env['HTTP_COOKIE'] = self.cookies.output(header='', sep='; ')
        env.update(extra)
        return Request.from_wsgi(env)

    def perform_request(self, request, user):
        request.website = test_website
        if user is not None:
            user = User.from_username(user)
            # Note that Cookie needs a bytestring.
            request.headers.cookie[str('session')] = user.session_token

        response = test_website.handle_safely(request)
        if response.headers.cookie:
            self.cookies.update(response.headers.cookie)
        return response

    def post(self, path, data, user=None, content_type=MULTIPART_CONTENT,
             **extra):
        """Perform a dummy POST request against the test website.

        :param path:
            The url to perform the virutal-POST to.

        :param data:
            A dictionary or list of tuples to be encoded before being POSTed.

        :param user:
            The user id performing the POST.

        Any additional parameters will be sent as headers. NOTE that in Aspen
        (request.py make_franken_headers) only headers beginning with ``HTTP``
        are included in the request - and those are changed to no longer
        include ``HTTP``. There are currently 2 exceptions to this:
        ``'CONTENT_TYPE'``, ``'CONTENT_LENGTH'`` which are explicitly checked
        for.
        """
        post_data = data

        if content_type is MULTIPART_CONTENT:
            post_data = encode_multipart(BOUNDARY, data)

        request = self.get_request(path, "POST", post_data,
                                   CONTENT_TYPE=str(content_type),
                                   **extra)
        return self.perform_request(request, user)

    def get(self, path, user=None, **extra):
        request = self.get_request(path, "GET")
        return self.perform_request(request, user)

# 需要导入模块: from Cookie import SimpleCookie [as 别名]
# 或者: from Cookie.SimpleCookie import update [as 别名]
	def __init__(self, response):
## 		self.code = response.code
## 		self.content = response.content
		
		cookies = SimpleCookie()
		try:
			cookies.update(response.cookies)
			cookies.update(response.session.sidcookie)
			cookies = str(cookies).split()[1]
			response.heads.set_cookie = cookies
		except AttributeError:
			pass
			

		
## 		self.heads = Heads(**kwargs)
## 		self.heads.content_type = response.content.ctype
## 		self.heads.content_length = response.content._clen
		response.heads.content_type = response.content.ctype
		response.heads.content_length = response.content._clen
		
		self.response = response

# 需要导入模块: from Cookie import SimpleCookie [as 别名]
# 或者: from Cookie.SimpleCookie import update [as 别名]
class HTTPClient(object):
    def __init__(self, http_client=None):
        self.http_client = http_client if http_client else \
            tornado.httpclient.HTTPClient()
        self.cookies = SimpleCookie()

    def get(self, url, data=None, headers={}): 
        if data is not None: 
            if isinstance(data, dict): 
                data = urlencode(data) 
            if '?' in url: 
                url += '&%s' % data 
            else: 
                url += '?%s' % data 
        return self.__fetch(url, 'GET', headers=headers)
    
    def post(self, url, data, headers={}): 
        if data is not None: 
            if isinstance(data, dict): 
                data = urlencode(data) 
        return self.__fetch(url, 'POST', data, headers)
    
    def __fetch(self, url, method, data=None, headers={}):
        #Send the cookies that have been previously set
        if len(self.cookies) > 0:
            headers["Cookie"] = self.cookies.output(attrs=[],
                header="",sep=";").strip()

        response = self.http_client.fetch(url, method=method,
                                          body=data, headers=headers)
        try:
            #Record any new cookies set
            self.cookies.update(SimpleCookie(response.headers["Set-Cookie"]))
        except KeyError:
            pass

        return response

# 需要导入模块: from Cookie import SimpleCookie [as 别名]
# 或者: from Cookie.SimpleCookie import update [as 别名]
class Client(object):
    """This is the Aspen test client. It is probably useful to you.
    """

    def __init__(self, www_root=None, project_root=None):
        self.www_root = www_root
        self.project_root = project_root
        self.cookie = SimpleCookie()
        self._website = None


    def hydrate_website(self, argv=None):
        if (self._website is None) or (argv is not None):
            argv = [ '--www_root', self.www_root
                   , '--project_root', self.project_root
                    ] + ([] if argv is None else argv)
            self._website = Website(argv)
        return self._website

    website = property(hydrate_website)


    def load_resource(self, path):
        """Given an URL path, return a Resource instance.
        """
        return self.hit('GET', path=path, return_after='get_resource_for_request', want='resource')


    # HTTP Methods
    # ============

    def GET(self, *a, **kw):    return self.hit('GET', *a, **kw)
    def POST(self, *a, **kw):   return self.hit('POST', *a, **kw)

    def GxT(self, *a, **kw):    return self.hxt('GET', *a, **kw)
    def PxST(self, *a, **kw):   return self.hxt('POST', *a, **kw)

    def hxt(self, *a, **kw):
        try:
            self.hit(*a, **kw)
        except Response as response:
            return response
        else:
            raise DidntRaiseResponse

    def hit(self, method, path='/', data=None, body=b'', content_type=MULTIPART_CONTENT,
            raise_immediately=True, return_after=None, want='response', **headers):

        data = {} if data is None else data
        if content_type is MULTIPART_CONTENT:
            body = encode_multipart(BOUNDARY, data)

        environ = self.build_wsgi_environ(method, path, body, str(content_type), **headers)
        state = self.website.respond( environ
                                    , raise_immediately=raise_immediately
                                    , return_after=return_after
                                     )

        response = state.get('response')
        if response is not None:
            if response.headers.cookie:
                self.cookie.update(response.headers.cookie)

        attr_path = want.split('.')
        base = attr_path[0]
        attr_path = attr_path[1:]

        out = state[base]
        for name in attr_path:
            out = getattr(out, name)

        return out


    def build_wsgi_environ(self, method, path, body, content_type, **kw):

        # NOTE that in Aspen (request.py make_franken_headers) only headers
        # beginning with ``HTTP`` are included in the request - and those are
        # changed to no longer include ``HTTP``. There are currently 2
        # exceptions to this: ``'CONTENT_TYPE'``, ``'CONTENT_LENGTH'`` which
        # are explicitly checked for.

        typecheck(path, (str, unicode), method, unicode, content_type, str, body, str)
        environ = {}
        environ[b'CONTENT_TYPE'] = content_type
        environ[b'HTTP_COOKIE'] = self.cookie.output(header=b'', sep=b'; ')
        environ[b'HTTP_HOST'] = b'localhost'
        environ[b'PATH_INFO'] = path if type(path) is str else path.decode('UTF-8')
        environ[b'REMOTE_ADDR'] = b'0.0.0.0'
        environ[b'REQUEST_METHOD'] = method.decode('ASCII')
        environ[b'SERVER_PROTOCOL'] = b'HTTP/1.1'
        environ[b'wsgi.input'] = StringIO(body)
        environ[b'HTTP_CONTENT_LENGTH'] = bytes(len(body))
        environ.update(kw)
        return environ

# 需要导入模块: from Cookie import SimpleCookie [as 别名]
# 或者: from Cookie.SimpleCookie import update [as 别名]
class TestClient(object):
    """
    The Aspen test client.

    Used in tests to emulate ``GET`` and ``POST`` requests by sending them
    into a ``Website`` instance's ``handle_safely`` method.

    Aspen does not define any User data structures or modules. If you want to
    do anything with users/sessions etc in your tests it is expected that you
    will subclass this TestClient and add a ``add_cookie_info`` method.

    For example, in gittip a suitable subclass might be::

        class GittipTestClient(TestClient):

            def add_cookie_info(self, request, cookie_info):
                if cookie_info:
                    user = cookie_info.get('user')
                    if user is not None:
                        user = User.from_id(user)
                        # Note that Cookie needs a bytestring.
                        request.headers.cookie['session'] = user.session_token

    Example usage in a test::

        def test_api_handles_posts():
            client = TestClient(website)

            # We need to get ourselves a token!
            response = client.get('/')
            csrf_token = response.request.context['csrf_token']

            # Then, add a $1.50 and $3.00 tip
            response = client.post("/test_tippee1/tip.json",
                                {'amount': "1.00", 'csrf_token': csrf_token},
                                cookie_info={'user': 'test_tipper'})

            # Confirm we get back the right amounts in the JSON body.
            first_data = json.loads(response.body)
            assert_equal(first_data['amount'], "1.00")
    """

    def __init__(self, website):
        self.cookies = SimpleCookie()
        self.test_website = website

    def get_request(self, path, method="GET", body=None, **extra):
        env = StubWSGIRequest(path)
        env["REQUEST_METHOD"] = method
        env["wsgi.input"] = StringIO(body)
        env["HTTP_COOKIE"] = self.cookies.output(header="", sep="; ")
        env.update(extra)
        return Request.from_wsgi(env)

    def perform_request(self, request, cookie_info):
        request.website = self.test_website
        self.add_cookie_info(request, **(cookie_info or {}))
        response = self.test_website.handle_safely(request)
        if response.headers.cookie:
            self.cookies.update(response.headers.cookie)
        return response

    def add_cookie_info(self, request, **cookie_info):
        """Place holder function that can be replaced in a subclass.

        For example in gittip.com, it might be of interest to load session
        information into the cookie like this::

            if cookie_info:
                user = cookie_info.get('user')
                if user is not None:
                    user = User.from_id(user)
                    # Note that Cookie needs a bytestring.
                    request.headers.cookie['session'] = user.session_token
        """
        pass

    def post(self, path, data, content_type=MULTIPART_CONTENT, cookie_info=None, **extra):
        """Perform a dummy POST request against the test website.

        :param path:
            The url to perform the virutal-POST to.

        :param data:
            A dictionary or list of tuples to be encoded before being POSTed.

        Any additional parameters will be sent as headers. NOTE that in Aspen
        (request.py make_franken_headers) only headers beginning with ``HTTP``
        are included in the request - and those are changed to no longer
        include ``HTTP``. There are currently 2 exceptions to this:
        ``'CONTENT_TYPE'``, ``'CONTENT_LENGTH'`` which are explicitly checked
        for.
        """
        post_data = data

        if content_type is MULTIPART_CONTENT:
            post_data = encode_multipart(BOUNDARY, data)

        request = self.get_request(path, "POST", post_data, CONTENT_TYPE=str(content_type), **extra)
        return self.perform_request(request, cookie_info)
#.........这里部分代码省略.........

# 需要导入模块: from Cookie import SimpleCookie [as 别名]
# 或者: from Cookie.SimpleCookie import update [as 别名]
    def run(self, environ, start_response):
        def tuplize(x):
            l = x.split("=")[:2]
            if len(l) == 1:
                l.append(True)
            return tuple(l)

        self.environ = environ
        self.start_response = start_response

        try:
            path_info = urllib.unquote_plus(environ["PATH_INFO"])
        except KeyError:
            raise WSGIKeyNotPresentError("PATH_INFO")

        path = [p for p in path_info.split("/") if p] or [""]
        if "QUERY_STRING" in environ:
            query_string = urllib.unquote_plus(environ["QUERY_STRING"])
            params = dict([tuplize(x) for x in query_string.split("&") if x])
        else:
            params = {}

            # a dirty little trick to deny FieldStorage to use QUERY_STRING
        self.environ["QUERY_STRING"] = ""

        xenviron = Struct()
        xenviron.args = path
        xenviron.kwargs = params
        try:
            xenviron.fields = FieldStorage(environ=self.environ, fp=self.environ["wsgi.input"])
        except KeyError:
            raise WSGIKeyNotPresentError("wsgi.input")
        xenviron.cookies = SimpleCookie(environ.get("HTTP_COOKIE", ""))

        try:
            xenviron.cookies, xenviron.session = self.sessionman.get_session(xenviron.cookies)
        except SessionError:
            xenviron.session = self.sessionman.new_session()

        if not path[0]:
            if not self._index:
                return self._default_index()

            app = self._index(xenviron)
        else:
            try:
                name = path[0]
                app = self._applist[name](xenviron)
            except KeyError:
                xenviron.error_code = 404
                xenviron.error_message = _(u"Method not found")

                if self._error:
                    app = self._error(xenviron)
                else:
                    return self._default_error(xenviron.error_code, xenviron.error_message)

        app.body.refresh(xenviron)
        app.body.run()
        app_xenviron, response = app.body.get()

        # further process the app_xenviron
        self.sessionman.update(app_xenviron.session)

        # return preparations
        cookies = SimpleCookie()
        cookies.update(app_xenviron.cookies)
        cookies.update(app_xenviron.session.sidcookie)
        cookies = str(cookies).split()[1]
        response.heads.set_cookie = cookies
        return self._prepare_response(response)