Python Client.get方法代码示例

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
def test_extends():
    config = setup()
    app = App(testing_config=config)
    extending = App(extends=[app], testing_config=config)

    @app.path(path='users/{username}')
    class User(object):
        def __init__(self, username):
            self.username = username

    @app.view(model=User)
    def render_user(self, request):
        return "User: %s" % self.username

    @extending.view(model=User, name='edit')
    def edit_user(self, request):
        return "Edit user: %s" % self.username

    config.commit()

    cl = Client(app, Response)
    response = cl.get('/users/foo')
    assert response.data == 'User: foo'
    response = cl.get('/users/foo/edit')
    assert response.status == '404 NOT FOUND'

    cl = Client(extending, Response)
    response = cl.get('/users/foo')
    assert response.data == 'User: foo'
    response = cl.get('/users/foo/edit')
    assert response.data == 'Edit user: foo'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
def test_default_render():
    app = Application([('/', hello_world_ctx, render_basic),
                       ('/<name>/', hello_world_ctx, render_basic),
                       ('/text/<name>/', hello_world_str, render_basic),
                       ('/html/<name>/', hello_world_html, render_basic),
                       ('/beta/<name>/', complex_context, render_basic)])

    yield ok_, callable(app.routes[0]._execute)
    yield ok_, callable(app.routes[0]._render)
    c = Client(app, BaseResponse)

    resp = c.get('/')  # test simple json with endpoint default
    yield eq_, resp.status_code, 200
    resp_data = json.loads(resp.data)
    yield eq_, resp_data['name'], 'world'

    resp = c.get('/Kurt/')  # test simple json with url param
    yield eq_, resp.status_code, 200
    resp_data = json.loads(resp.data)
    yield eq_, resp_data['name'], 'Kurt'

    resp = c.get('/beta/Rajkumar/')  # test fancy json
    yield eq_, resp.status_code, 200
    resp_data = json.loads(resp.data)
    yield eq_, resp_data['name'], 'Rajkumar'
    yield ok_, resp_data['date']
    yield ok_, len(resp_data) > 4

    resp = c.get('/text/Noam/')  # test text
    yield eq_, resp.status_code, 200
    yield eq_, resp.data, 'Hello, Noam!'

    resp = c.get('/html/Asia/')  # test basic html
    yield eq_, resp.status_code, 200
    yield ok_, 'text/html' in resp.headers['Content-Type']

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
class TestPurgeComments(unittest.TestCase):

    def setUp(self):
        fd, self.path = tempfile.mkstemp()
        conf = core.Config.load(None)
        conf.set("general", "dbpath", self.path)
        conf.set("moderation", "enabled", "true")
        conf.set("guard", "enabled", "off")

        class App(Isso, core.Mixin):
            pass

        self.app = App(conf)
        self.app.wsgi_app = FakeIP(self.app.wsgi_app)
        self.client = Client(self.app, Response)

    def testPurgeDoesNoHarm(self):
        self.client.post('/new?uri=test', data=json.dumps({"text": "..."}))
        self.app.db.comments.activate(1)
        self.app.db.comments.purge(0)
        assert self.client.get('/?uri=test').status_code == 200

    def testPurgeWorks(self):
        self.client.post('/new?uri=test', data=json.dumps({"text": "..."}))
        self.app.db.comments.purge(0)
        assert self.client.get('/id/1').status_code == 404

        self.client.post('/new?uri=test', data=json.dumps({"text": "..."}))
        self.app.db.comments.purge(3600)
        assert self.client.get('/id/1').status_code == 200

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
    def test_auth_unique_uri(self):
        from rest_api_framework.pagination import Pagination

        ressources = [{"id": "azerty"}]
        authentication = ApiKeyAuthentication(
            PythonListDataStore(ressources,
                                ApiModel)
            )

        class ApiAppAuth(ApiApp):
            controller = {
                "list_verbs": ["GET", "POST"],
                "unique_verbs": ["GET", "PUT", "DElETE"],
                "options": {"pagination": Pagination(20),
                            "authentication": authentication,
                            "authorization": ApiKeyAuthorization
                            }
                }

        client = Client(
            WSGIDispatcher([ApiAppAuth]),
            response_wrapper=BaseResponse)

        resp = client.get("/address/1/?apikey=azerty")
        self.assertEqual(resp.status_code, 200)
        resp = client.get("/address/1/?apikey=querty")
        self.assertEqual(resp.status_code, 401)

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

    def setUp(self):
        super(ServerTestCase, self).setUp()

        self.app = FlaskApp(__name__)
        self.app.route('/', methods=['POST', 'GET'])(hello_world)
        ctx = self.app.test_request_context()
        ctx.push()
        self.addCleanup(ctx.pop)
        self.client = Client(self.app, response_wrapper=Response)

    def test_trace_generated(self):
        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)
        self.assertIn(TRACE_HEADER, response.headers.keys())

    def test_trace_is_unique_per_request(self):
        response = self.client.get('/')
        value1 = response.headers[TRACE_HEADER]
        response = self.client.get('/')
        value2 = response.headers[TRACE_HEADER]
        self.assertNotEqual(value1, value2)

    def test_trace_prefixing(self):
        response = self.client.get('/')
        value = response.headers[TRACE_HEADER]
        self.assertTrue(value.startswith(TRACE_PREFIX), value)

    def test_multiple_requests_appended(self):
        headers = {TRACE_HEADER: 'Trace123'}
        response = self.client.get('/', headers=headers)
        value = response.headers[TRACE_HEADER]
        self.assertTrue(value.startswith('Trace123,' + TRACE_PREFIX))

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

    app = CORSMiddleware(hello_world, hosts=[
        "https://example.tld/",
        "http://example.tld/",
        "http://example.tld",
    ])

    client = Client(app, Response)

    rv = client.get("/", headers={"ORIGIN": "https://example.tld"})

    assert rv.headers["Access-Control-Allow-Origin"] == "https://example.tld"
    assert rv.headers["Access-Control-Allow-Headers"] == "Origin, Content-Type"
    assert rv.headers["Access-Control-Allow-Credentials"] == "true"
    assert rv.headers["Access-Control-Allow-Methods"] == "GET, POST, PUT, DELETE"
    assert rv.headers["Access-Control-Expose-Headers"] == "X-Set-Cookie"

    a = client.get("/", headers={"ORIGIN": "http://example.tld/"})
    assert a.headers["Access-Control-Allow-Origin"] == "http://example.tld"

    b = client.get("/", headers={"ORIGIN": "http://example.tld"})
    assert a.headers["Access-Control-Allow-Origin"] == "http://example.tld"

    c = client.get("/", headers={"ORIGIN": "http://foo.other/"})
    assert a.headers["Access-Control-Allow-Origin"] == "http://example.tld"

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
def test_mount_empty_context():
    app = morepath.App('app')
    mounted = morepath.App('mounted')

    class MountedRoot(object):
        pass

    def root_default(request, model):
        return "The root"

    def root_link(request, model):
        return request.link(model)

    def get_context():
        pass

    c = setup()
    c.configurable(app)
    c.configurable(mounted)
    c.action(app.mount(path='{id}', app=mounted), get_context)
    c.action(mounted.root(), MountedRoot)
    c.action(mounted.view(model=MountedRoot),
             root_default)
    c.action(mounted.view(model=MountedRoot, name='link'),
             root_link)
    c.commit()

    c = Client(app, Response)

    response = c.get('/foo')
    assert response.data == 'The root'

    response = c.get('/foo/link')
    assert response.data == 'foo'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
 def test_wsgi_sass_middleware(self):
     css_dir = tempfile.mkdtemp()
     src_dir = os.path.join(css_dir, 'src')
     shutil.copytree('test', src_dir)
     try:
         app = SassMiddleware(self.sample_wsgi_app, {
             __name__: (src_dir, css_dir, '/static')
         })
         client = Client(app, Response)
         r = client.get('/asdf')
         self.assertEqual(200, r.status_code)
         self.assert_bytes_equal(b'/asdf', r.data)
         self.assertEqual('text/plain', r.mimetype)
         r = client.get('/static/a.scss.css')
         self.assertEqual(200, r.status_code)
         src_path = normalize_path(os.path.join(src_dir, 'a.scss'))
         self.assert_bytes_equal(
             b(A_EXPECTED_CSS_WITH_MAP.replace('SOURCE', src_path)),
             r.data
         )
         self.assertEqual('text/css', r.mimetype)
         r = client.get('/static/not-exists.sass.css')
         self.assertEqual(200, r.status_code)
         self.assert_bytes_equal(b'/static/not-exists.sass.css', r.data)
         self.assertEqual('text/plain', r.mimetype)
     finally:
         shutil.rmtree(css_dir)

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

    class AccumErrorHandler(ErrorHandler):
        def render_error(self, _error, request, error_list, **kwargs):
            if 'reraise' in request.path:
                raise _error
            if 'badgateway' in request.path:
                _error = BadGateway()
            error_list.append(_error)
            return _error

    rt = Route('/<number:int>/<option?>', odd_endpoint, render_basic)
    error_list = []
    rsrc = {'error_list': error_list}
    app = Application([rt], rsrc, error_handler=AccumErrorHandler())
    cl = Client(app, BaseResponse)

    err_resp = cl.get('/39')
    yield eq_, err_resp.status_code, 200
    err_resp = cl.get('/2')
    yield eq_, err_resp.status_code, 500
    yield eq_, len(error_list), 1

    # reraising means the error will be handled by the default
    # handler, so no length change should occur
    err_resp = cl.get('/4/reraise')
    yield eq_, err_resp.status_code, 500
    yield eq_, len(error_list), 1

    err_resp = cl.get('/6/badgateway')
    #if err_resp.status_code != 502:
    #    import pdb;pdb.set_trace()
    yield eq_, err_resp.status_code, 502
    yield eq_, len(error_list), 2

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
class TestWSGI(unittest.TestCase):

    def setUp(self):
        module_path = os.path.dirname(os.path.abspath(__file__))
        self.test_project = os.path.join(module_path, 'testproject')

        self.app = shortstack.wsgi.Shortstack('shortstack', instance_path=self.test_project)
        self.client = Client(self.app, BaseResponse)

    def test_render_through_app(self):
        look_for = "This text only exists in the base template"
        response_implied_index = self.client.get('/')
        response_explicit_index = self.client.get('/index.html')

        self.assertIn(look_for, str(response_implied_index.data)) 
        self.assertEqual(response_implied_index.data, response_explicit_index.data)

    def test_build_search_path(self):
        search_path = self.app.build_search_path('/foo/bar/baz/index.html')        
        first_item_should_be = os.path.join(self.test_project,'foo/bar/baz/')

        self.assertEqual(first_item_should_be, search_path[0])
        self.assertEqual(self.test_project, os.path.normpath(search_path[-1]))
        
    def test_add_slash(self):
        response = self.client.get('/foo')
        self.assertEqual(response.status_code, 302)
        self.assertIn('Location', response.headers)
        self.assertEqual(response.headers['Location'], "http://localhost/foo/")

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
class WebIntegrationTest(unittest.TestCase):

    def setUp(self):
        super(WebIntegrationTest, self).setUp()
        container = mock.Mock()
        container.debug = False
        self.interface = Web(container)
        self.http_client = Client(self.interface.application, BaseResponse)

    def test_dispatch_rule_with_string_endpoint(self):
        response = self.http_client.get("/test/")
        self.assertEqual(response.data.decode("utf8"), "method test")
        self.assertEqual(response.status_code, 200)

    def test_dispatch_rule_with_callable_endpoint(self):
        response = self.http_client.get("/foo/")
        self.assertEqual(response.data.decode("utf8"), "Rule Handler")
        self.assertEqual(response.status_code, 200)

    def test_dispatch_handled_rule(self):
        response = self.http_client.get("/bar/")
        self.assertEqual(response.data.decode("utf8"), "Handled Rule Handler")
        self.assertEqual(response.status_code, 200)

    def test_dispatch_failing_rule_to_500(self):
        response = self.http_client.get("/fail/")
        self.assertEqual(response.data.decode("utf8"), "")
        self.assertEqual(response.status_code, 500)

    def test_dispatch_failing_endpoint_to_500(self):
        response = self.http_client.get("/fail-wrong-endpoint/")
        self.assertEqual(response.data.decode("utf8"), "")
        self.assertEqual(response.status_code, 500)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
    def test_full_flow(self, satosa_config_dict, account_linking_module_config):
        api_url = "https://alservice.example.com/api"
        redirect_url = "https://alservice.examle.com/redirect"
        account_linking_module_config["config"]["api_url"] = api_url
        account_linking_module_config["config"]["redirect_url"] = redirect_url
        satosa_config_dict["MICRO_SERVICES"].insert(0, account_linking_module_config)

        # application
        test_client = Client(make_app(SATOSAConfig(satosa_config_dict)), BaseResponse)

        # incoming auth req
        http_resp = test_client.get("/{}/{}/request".format(satosa_config_dict["BACKEND_MODULES"][0]["name"],
                                                            satosa_config_dict["FRONTEND_MODULES"][0]["name"]))
        assert http_resp.status_code == 200

        with responses.RequestsMock() as rsps:
            # fake no previous account linking
            rsps.add(responses.GET, "{}/get_id".format(api_url), "test_ticket", status=404)

            # incoming auth resp
            http_resp = test_client.get("/{}/response".format(satosa_config_dict["BACKEND_MODULES"][0]["name"]))
            assert http_resp.status_code == 302
            assert http_resp.headers["Location"].startswith(redirect_url)

        with responses.RequestsMock() as rsps:
            # fake previous account linking
            rsps.add(responses.GET, "{}/get_id".format(api_url), "test_userid", status=200)

            # incoming account linking response
            http_resp = test_client.get("/account_linking/handle_account_linking")
            assert http_resp.status_code == 200

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
class TestFieldLimiter(TestCase):
    def setUp(self):
        app = FieldLimiter(dummy_json_app)
        self.client = Client(app, BaseResponse)

    def test_no_limiting(self):
        resp = self.client.get("/")
        self.assertEqual(json_resp(resp), test_data)

    def test_limit_one(self):
        resp = self.client.get("/?field=message")
        self.assertEqual(json_resp(resp), {"message": test_data["message"]})

    def test_limit_multi(self):
        fields = ("message", "errors")
        resp = self.client.get("/?field={}&field={}".format(*fields))
        expecting = {k: v for k, v in test_data.items() if k in fields}
        self.assertEqual(json_resp(resp), expecting)

    def test_limit_bad(self):
        with self.assertRaises(BadRequest):
            resp = self.client.get("/?field=nonexistentfield")

    def test_list_limit(self):
        def app(environ, start_response):
            """Stupid app that sends a deep message: hello world"""
            response = BaseResponse(json.dumps([test_data] * 2), mimetype="application/json")
            return response(environ, start_response)

        wrapped = FieldLimiter(app)
        c = Client(wrapped, BaseResponse)
        resp = c.get("/?field=message")
        self.assertEqual(json_resp(resp), [{"message": test_data["message"]}] * 2)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
def test_overrides_model():
    config = setup()
    app = App(testing_config=config)
    overriding = App(extends=[app], testing_config=config)

    @app.path(path='users/{username}')
    class User(object):
        def __init__(self, username):
            self.username = username

    @app.view(model=User)
    def render_user(self, request):
        return "User: %s" % self.username

    @overriding.path(model=User, path='users/{username}')
    def get_user(username):
        if username != 'bar':
            return None
        return User(username)

    config.commit()

    cl = Client(app, Response)
    response = cl.get('/users/foo')
    assert response.data == 'User: foo'
    response = cl.get('/users/bar')
    assert response.data == 'User: bar'

    cl = Client(overriding, Response)
    response = cl.get('/users/foo')
    assert response.status == '404 NOT FOUND'
    response = cl.get('/users/bar')
    assert response.data == 'User: bar'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import get [as 别名]
def test_link_for_none_means_no_parameter():
    config = setup()
    app = morepath.App(testing_config=config)

    class Model(object):
        def __init__(self, id):
            self.id = id

    @app.path(model=Model, path='')
    def get_model(id):
        return Model(id)

    @app.view(model=Model)
    def default(self, request):
        return "View: %s" % self.id

    @app.view(model=Model, name='link')
    def link(self, request):
        return request.link(self)

    config.commit()

    c = Client(app, Response)

    response = c.get('/')
    assert response.data == "View: None"

    response = c.get('/link')
    assert response.data == '/'