Python Client.open方法代码示例

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
def test_check_login():
    from glashammer.bundles.auth import setup_auth, login
    from glashammer.bundles.sessions import get_session

    called = []

    def check(u, p):
        called.append((u, p))
        return u == p

    def view(req):
        login('a')
        return Response()

    def setup_app(app):
        app.add_setup(setup_auth)
        app.connect_event('password-check', check)
        app.add_url('/', 'a/b', view=view)

    app = make_app(setup_app, 'test_output')
    c = Client(app)
    c.open()

    session = get_session()
    token_key = get_app().conf['auth/token_key']
    assert token_key in session
    assert session[token_key] == 'a'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
class TestJsonRestService(object):

    def setup(self):
        def _setup_json(app):
            app.add_url('/', '', view=_Service())

        app = make_app(_setup_json, 'test_output')

        self.client = Client(app)

    def test_get(self):
        ai, st, h = self.client.open(method='GET')
        s = list(ai)[0]
        assert 'GET' in s

    def test_post(self):
        ai, st, h = self.client.open(method='POST')
        s = list(ai)[0]
        assert 'POST' in s

    def test_put(self):
        ai, st, h = self.client.open(method='PUT')
        s = list(ai)[0]
        assert 'PUT' in s

    def test_delete(self):
        ai, st, h = self.client.open(method='DELETE')
        s = list(ai)[0]
        assert 'DELETE' in s

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
class TestJsonRest(object):

    def setup(self):
        app = load_app_from_path('examples/jsonrest/run.py')
        self.c = Client(app)

    def test_index(self):
        iter, status, headers = self.c.open()
        s = ''.join(iter)
        assert  """
    <a href="#" id="get_link">GET</a>
    <a href="#" id="post_link">POST</a>
    <a href="#" id="put_link">PUT</a>
    <a href="#" id="delete_link">DELETE</a>
""".strip('\n') in s

    def test_get(self):
        iter, status, headers = self.c.open('/svc')
        d = loads(''.join(iter))
        assert d['type'] == 'GET'

    def test_put(self):
        iter, status, headers = self.c.put('/svc')
        d = loads(''.join(iter))
        assert d['type'] == 'PUT'

    def test_delete(self):
        iter, status, headers = self.c.delete('/svc')
        d = loads(''.join(iter))
        assert d['type'] == 'DELETE'

    def test_post(self):
        iter, status, headers = self.c.post('/svc')
        d = loads(''.join(iter))
        assert d['type'] == 'POST'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
def test_context_error_propagates(app, environ):
    # The Protector relies on any errors being raised by a request 
    # context manager being propagated all the way to the application
    # error handler. Should these test cases fail, then the Protector
    # will fail to do its job.
    class CustomErrorClass(Exception):
        pass

    err = CustomErrorClass()
    tracked = []

    @app.context
    def error_func():
        raise err
        yield

    @app.error_handler.register(CustomErrorClass)
    def track_error(e):
        tracked.append(e)
        return BaseResponse("Foo")

    client = Client(app)
    client.open(environ)

    assert tracked == [err]

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
class WsgiAPIClient(BaseAPIClient):
    wsgi_app = None
    server_cosmos = None

    def __init__(self, *args, **kwargs):
        self.client = WerkzeugTestClient(self.wsgi_app, response_wrapper=Response)
        spec = self.call(SpecEndpoint())
        super(WsgiAPIClient, self).__init__(*args, spec=spec, **kwargs)

    def make_request(self, endpoint, request):
        kwargs = {
            "method": request.method,
            "data": request.data,
            "headers": request.headers
        }
        # Content-Type should be provided as kwarg because otherwise we can't
        # access request.mimetype
        if 'Content-Type' in request.headers:
            kwargs['content_type'] = request.headers.pop('Content-Type')

        if self.server_cosmos is None:
            r = self.client.open(path=request.url, **kwargs)
        else:
            with cosmos.swap(self.server_cosmos):
                r = self.client.open(path=request.url, **kwargs)


        resp = requests.Response()
        resp._content = r.data
        resp.headers = CaseInsensitiveDict(r.headers)
        resp.status_code = r.status_code

        return resp

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
def test_resent_cookie():
    """Test that the client resends cookies on subsequent requests
    """
    c = Client(cookie_app)
    c.open()
    appiter, code, headers = c.open()
    assert ''.join(appiter) == 'test=test'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
def test_disable_cookies():
    """Ensure that cookies are not stored when use_cookies is False in the
    client
    """
    c = Client(cookie_app, use_cookies=False)
    c.open()
    appiter, code, headers = c.open()
    assert ''.join(appiter) == 'No Cookie'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
def test_cookie_for_different_path():
    """Test that the client resends cookies on subsequent requests for
    different paths
    """
    c = Client(cookie_app)
    c.open('/path1')
    appiter, code, headers = c.open('/path2')
    assert ''.join(appiter) == 'test=test'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
def test_autorules_client():
    app = gh_app(_setup)
    c = Client(app)

    i, s, h = c.open('/')
    assert '404' in s

    i, s, h = c.open('/pages/')
    print i, s, h
    assert '200' in s
    assert 'hello' in ''.join(i)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
def test_session_setup():

    def _setup_sessions(app):
        from glashammer.bundles.sessions import setup_app
        app.add_setup(setup_app)

        app.add_url('/', '', view=_sessioned_view)

    app = make_app(_setup_sessions, 'test_output')

    c = Client(app)
    c.open()

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
def test_event_log_handler():
    
    logs = []

    def log(level, record):
        logs.append((level, record))

    def setup_app(app):
        app.connect_event('log', log)

    app = make_app(setup_app, 'test_output')
    c = Client(app)
    c.open()
    assert len(logs) > 5

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
def _test_finalized():

    def _bview(req):
        app = get_app()
        assert_raises((RuntimeError,), app.add_config_var, 'a', str, 'a')
        return Response('hello')

    def _setup_app(app):
        app.add_url('/', 'hoo', _bview)

    app = make_app(_setup_app, 'test_output')

    c = Client(app)
    c.open()

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
class TestHelloWorld(object):

    def setup(self):
        app = load_app_from_path('examples/helloworld/run.py')
        self.c = Client(app)

    def test_index(self):
        iter, status, headers = self.c.open()
        assert ' '.join(iter) == '<h1>Hello World</h1>'
        assert status == '200 OK'

    def test_notfound(self):
        iter, status, headers = self.c.open('/blah')
        assert status == '404 NOT FOUND'
        assert '404 Not Found' in ' '.join(iter)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
	def test_vote_page_check_scope(self):
		cache = StrictRedis(db=config.tokens_cache_redis_db)

		h = Headers()
		h.add('Authorization',
			  'Basic ' + base64.b64encode(config.test_token + ':'))
		rv = Client.open(self.client, path='/people/v1/vote/hhauer',
						 headers=h)
		self.assert_200(rv)
		
		cache.srem(config.people_scope_vote, '[email protected]')

		rv = Client.open(self.client, path='/people/v1/vote/hhauer',
						 headers=h)
		self.assert_403(rv)
		cache.sadd(config.people_scope_vote, '[email protected]')

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import open [as 别名]
 def test_admin_page_rejects_bad_password(self):
     """ Check that incorrect password won't allow access """
     h = Headers()
     auth = '{0}:foo'.format(Config.USERNAME).encode('ascii')
     h.add('Authorization', b'Basic ' + base64.b64encode(auth))
     rv = Client.open(self.client, path='/', headers=h)
     self.assert_401(rv)