This is an automated email from the ASF dual-hosted git repository.
shuaijinchao pushed a commit to branch master
in repository
https://gitbox.apache.org/repos/asf/apisix-python-plugin-runner.git
The following commit(s) were added to refs/heads/master by this push:
new 8a8992d refactor(req+resp): unified request and response object
interface (#42)
8a8992d is described below
commit 8a8992d550fad2c5e7b76eb01f6c6e65e0aabe3e
Author: 帅进超 <[email protected]>
AuthorDate: Wed Feb 16 10:56:35 2022 +0800
refactor(req+resp): unified request and response object interface (#42)
---
apisix/plugins/rewrite.py | 6 +-
apisix/plugins/stop.py | 6 +-
apisix/runner/http/request.py | 326 +++++++++++++++++++------------------
apisix/runner/http/response.py | 223 ++++++++-----------------
apisix/runner/server/handle.py | 10 +-
tests/runner/http/test_request.py | 104 +++++++-----
tests/runner/http/test_response.py | 63 ++++---
7 files changed, 343 insertions(+), 395 deletions(-)
diff --git a/apisix/plugins/rewrite.py b/apisix/plugins/rewrite.py
index e44900f..dd81026 100644
--- a/apisix/plugins/rewrite.py
+++ b/apisix/plugins/rewrite.py
@@ -54,10 +54,10 @@ class Rewrite(PluginBase):
# print(conf)
# Rewrite request headers
- request.headers["X-Resp-A6-Runner"] = "Python"
+ request.set_header("X-Resp-A6-Runner", "Python")
# Rewrite request args
- request.args["a6_runner"] = "Python"
+ request.set_arg("a6_runner", "Python")
# Rewrite request path
- request.path = "/a6/python/runner"
+ request.set_uri("/a6/python/runner")
diff --git a/apisix/plugins/stop.py b/apisix/plugins/stop.py
index 86ce5e9..86b90ae 100644
--- a/apisix/plugins/stop.py
+++ b/apisix/plugins/stop.py
@@ -54,10 +54,10 @@ class Stop(PluginBase):
# print(conf)
# Set response headers
- response.headers["X-Resp-A6-Runner"] = "Python"
+ response.set_header("X-Resp-A6-Runner", "Python")
# Set response body
- response.body = "Hello, Python Runner of APISIX"
+ response.set_body("Hello, Python Runner of APISIX")
# Set response status code
- response.status_code = 201
+ response.set_status_code(201)
diff --git a/apisix/runner/http/request.py b/apisix/runner/http/request.py
index a318198..e3c2196 100644
--- a/apisix/runner/http/request.py
+++ b/apisix/runner/http/request.py
@@ -24,6 +24,7 @@ from A6.HTTPReqCall import Rewrite as HCRw
from A6.HTTPReqCall import Action as HCAction
from A6.HTTPReqCall import Req as HCReq
from A6.PrepareConf import Req as PCReq
+from A6.Err.Code import Code as A6ErrCode
class Request:
@@ -34,295 +35,305 @@ class Request:
:param r:
rpc request object
"""
- self._rpc_type = r.request.ty
- self._rpc_buf = r.request.data
- self._req_id = 0
- self.code = 0
- self._req_conf_token = 0
- self._req_method = ""
- self._req_path = ""
- self._req_headers = {}
- self._req_configs = {}
- self._req_args = {}
- self._req_src_ip = ""
- self._err_code = 0
- self.__init()
+ # request object
+ self.r = r
- @property
- def rpc_type(self) -> int:
- """
- get request protocol type for request handler
- :return:
- """
- return self._rpc_type
+ # request attribute
+ self.__remote_addr = ""
+ self.__headers = {}
+ self.__args = {}
+ self.__uri = ""
+ self.__method = ""
- @rpc_type.setter
- def rpc_type(self, rpc_type: int) -> None:
- """
- set request protocol type for request handler
- :param rpc_type:
- :return:
- """
- self._rpc_type = rpc_type
+ # custom attribute
+ self.__conf_token = 0
+ self.__id = 0
+ self.__configs = {}
+
+ self.__init()
- @property
- def rpc_buf(self) -> bytes:
+ def get_header(self, key: str) -> str:
"""
- get request buffer data for request handler
+ get request header
+ :param key:
:return:
"""
- return self._rpc_buf
+ return self.__headers.get(key)
- @rpc_buf.setter
- def rpc_buf(self, rpc_buf: bytes) -> None:
+ def set_header(self, key: str, value: str) -> bool:
"""
- set request buffer data for request handler
+ set request header
+ :param key:
+ :param value:
:return:
"""
- self._rpc_buf = rpc_buf
+ if key and value:
+ self.__headers[key] = value
+ return True
+ return False
- @property
- def conf_token(self) -> int:
+ def get_headers(self) -> dict:
"""
- get request token for request handler
+ get request headers
:return:
"""
- return self._req_conf_token
+ return self.__headers
- @conf_token.setter
- def conf_token(self, req_conf_token: int) -> None:
+ def set_headers(self, headers: dict) -> bool:
"""
- set request token for request handler
+ get request headers
+ :param headers:
:return:
"""
- self._req_conf_token = req_conf_token
+ if headers:
+ self.__headers = headers
+ return True
+ return False
- @property
- def id(self) -> int:
+ def get_arg(self, key: str) -> str:
"""
- get request id for request handler
+ get request param
+ :param key:
:return:
"""
- return self._req_id
+ return self.__args.get(key)
- @id.setter
- def id(self, req_id: int) -> None:
+ def set_arg(self, key: str, value: str) -> bool:
"""
- set request id for request handler
+ set request param
+ :param key:
+ :param value:
:return:
"""
- self._req_id = req_id
+ if key and value:
+ self.__args[key] = value
+ return True
+ return False
- @property
- def method(self) -> str:
+ def get_args(self) -> dict:
"""
- get request method for request handler
+ get request params
:return:
"""
- return self._req_method
+ return self.__args
- @method.setter
- def method(self, req_method: str) -> None:
+ def set_args(self, args: dict) -> bool:
"""
- set request method for request handler
+ set request params
+ :param args:
:return:
"""
- self._req_method = req_method
+ if args:
+ self.__args = args
+ return True
+ return False
- @property
- def path(self) -> str:
+ def get_uri(self) -> str:
"""
- get request path for request handler
+ get request uri
:return:
"""
- return self._req_path
+ return self.__uri
- @path.setter
- def path(self, req_path: str) -> None:
+ def set_uri(self, uri: str) -> bool:
"""
- set request path for request handler
+ set request uri
+ :param uri:
:return:
"""
- self._req_path = req_path
+ if uri and uri.startswith("/"):
+ self.__uri = uri
+ return True
+ return False
- @property
- def headers(self) -> dict:
+ def get_remote_addr(self) -> str:
"""
- get request headers for request handler
+ get request client ip address
:return:
"""
- return self._req_headers
+ return self.__remote_addr
- @headers.setter
- def headers(self, req_headers: dict) -> None:
+ def set_remote_addr(self, remote_addr: str) -> bool:
"""
- set request headers for request handler
+ set request client ip address
+ :param remote_addr:
:return:
"""
- self._req_headers = req_headers
+ if remote_addr:
+ self.__remote_addr = remote_addr
+ return True
+ return False
- @property
- def configs(self) -> dict:
+ def get_conf_token(self) -> int:
"""
- get plugin instance and configs for request handler
+ get request config token
:return:
"""
- return self._req_configs
+ return self.__conf_token
- @configs.setter
- def configs(self, req_configs: dict) -> None:
+ def set_conf_token(self, conf_token: int) -> bool:
"""
- set plugin instance and configs for request handler
+ set request config token
+ :param conf_token:
:return:
"""
- self._req_configs = req_configs
+ if conf_token:
+ self.__conf_token = conf_token
+ return True
+ return False
- @property
- def args(self) -> dict:
+ def get_id(self):
"""
- get request args for request handler
+ get request id
:return:
"""
- return self._req_args
+ return self.__id
- @args.setter
- def args(self, req_args: dict) -> None:
+ def set_id(self, id: int):
"""
- set request args for request handler
+ set request id
+ :param id:
:return:
"""
- self._req_args = req_args
+ if id:
+ self.__id = id
+ return True
+ return False
- @property
- def src_ip(self) -> str:
+ def set_method(self, method: str) -> bool:
"""
- get request source ip address for request handler
+ set request method
+ :param method:
:return:
"""
- return self._req_src_ip
+ # support common request method setting
+ if method and method.upper() in ["GET", "POST", "PUT", "DELETE",
"HEAD", "OPTIONS", "PATCH"]:
+ self.__method = method
+ return True
+ return False
- @src_ip.setter
- def src_ip(self, req_src_ip: str) -> None:
+ def get_method(self) -> str:
"""
- set request source ip address for request handler
+ get request method
:return:
"""
- self._req_src_ip = req_src_ip
+ return self.__method
- @property
- def err_code(self) -> int:
+ def set_config(self, key: str, value: str):
"""
- get error code for request handler
+ set plugin config
+ :param key:
+ :param value:
:return:
"""
- return self._err_code
+ if key and value:
+ self.__configs[key] = value
+ return True
+ return False
- @err_code.setter
- def err_code(self, err_code: int) -> None:
+ def get_config(self, key: str) -> str:
"""
- set error code for request handler
+ get plugin config
+ :param key:
:return:
"""
- self._err_code = err_code
+ return self.__configs.get(key)
- def reset(self) -> None:
+ def get_configs(self) -> dict:
"""
- reset request handler
+ get plugin configs
:return:
"""
+ return self.__configs
+
+ def set_configs(self, configs: dict) -> bool:
"""
- reset request class
+ set plugin configs
:return:
"""
- self._rpc_type = 0
- self._rpc_buf = b''
- self._req_id = 0
- self._req_conf_token = 0
- self._req_method = ""
- self._req_path = ""
- self._req_headers = {}
- self._req_configs = {}
- self._req_args = {}
- self._req_src_ip = ""
+ if configs:
+ self.__configs = configs
+ return True
+ return False
def __init(self) -> None:
"""
init request handler
:return:
"""
- if self.rpc_type == runner_utils.RPC_HTTP_REQ_CALL:
- req = HCReq.Req.GetRootAsReq(self.rpc_buf)
+ if self.r.request.ty == runner_utils.RPC_HTTP_REQ_CALL:
+ req = HCReq.Req.GetRootAsReq(self.r.request.data)
# fetch request id
- self.id = req.Id()
+ self.set_id(req.Id())
# fetch request conf token
- self.conf_token = req.ConfToken()
-
- # fetch request uri
- self.path = req.Path().decode()
+ self.set_conf_token(req.ConfToken())
# fetch request method
- self.method = runner_utils.get_method_name_by_code(req.Method())
+ self.set_method(runner_utils.get_method_name_by_code(req.Method()))
# fetch request remote_addr
ip_list = runner_utils.parse_list_vector(req,
runner_utils.VECTOR_TYPE_SOURCE_IP, True)
- if ip_list:
- if len(ip_list) == 16:
- self.src_ip = IPv6Address(bytes(ip_list)).exploded
- else:
- self.src_ip = IPv4Address(bytes(ip_list)).exploded
+ if len(ip_list) == 16:
+ self.set_remote_addr(IPv6Address(bytes(ip_list)).exploded)
+ else:
+ self.set_remote_addr(IPv4Address(bytes(ip_list)).exploded)
+
+ # fetch request uri
+ self.set_uri(req.Path().decode())
# fetch request headers
hdr_dict = runner_utils.parse_dict_vector(req,
runner_utils.VECTOR_TYPE_HEADER)
- if hdr_dict:
- self.headers = hdr_dict
+ self.set_headers(hdr_dict)
# fetch request args
arg_dict = runner_utils.parse_dict_vector(req,
runner_utils.VECTOR_TYPE_QUERY)
- if arg_dict:
- self.args = arg_dict
+ self.set_args(arg_dict)
- if self.rpc_type == runner_utils.RPC_PREPARE_CONF:
- req = PCReq.Req.GetRootAsReq(self.rpc_buf)
- if req.ConfIsNone():
- return
-
- configs = {}
+ if self.r.request.ty == runner_utils.RPC_PREPARE_CONF:
+ req = PCReq.Req.GetRootAsReq(self.r.request.data)
for i in range(req.ConfLength()):
# fetch request config
name = req.Conf(i).Name().decode()
config = req.Conf(i).Value().decode()
- configs[name] = config
- self.configs = configs
+ self.set_config(name, config)
def checked(self):
"""
check request params is valid
:return:
"""
- if len(self._req_path) == 0 and len(self._req_headers) == 0 and
len(self._req_args) == 0:
+ if len(self.__uri) == 0 and len(self.__headers) == 0 and
len(self.__args) == 0:
return False
else:
return True
@runner_utils.response_config
def config_handler(self, builder: flatbuffers.Builder):
- return self.conf_token
+ """
+ get config setting response
+ :param builder:
+ :return:
+ """
+ return self.get_conf_token()
@runner_utils.response_call(HCAction.Action.Rewrite)
def call_handler(self, builder: flatbuffers.Builder):
+ """
+ get http call response
+ :param builder:
+ :return:
+ """
if not self.checked():
return None, 0
- if len(self._req_path) <= 0:
- self._req_path = "/"
- path_vector = runner_utils.create_str_vector(builder, self._req_path)
+ path_vector = runner_utils.create_str_vector(builder, self.get_uri())
- headers_vector = runner_utils.create_dict_vector(builder,
self._req_headers, HCAction.Action.Rewrite,
+ headers_vector = runner_utils.create_dict_vector(builder,
self.get_headers(), HCAction.Action.Rewrite,
runner_utils.VECTOR_TYPE_HEADER)
- args_vector = runner_utils.create_dict_vector(builder, self._req_args,
HCAction.Action.Rewrite,
+ args_vector = runner_utils.create_dict_vector(builder,
self.get_args(), HCAction.Action.Rewrite,
runner_utils.VECTOR_TYPE_QUERY)
HCRw.RewriteStart(builder)
@@ -330,8 +341,13 @@ class Request:
HCRw.RewriteAddHeaders(builder, headers_vector)
HCRw.RewriteAddArgs(builder, args_vector)
rewrite = HCRw.RewriteEnd(builder)
- return rewrite, self._req_id
+ return rewrite, self.get_id()
@runner_utils.response_unknown
def unknown_handler(self, builder: flatbuffers.Builder):
- return self._err_code
+ """
+ get unknown response
+ :param builder:
+ :return:
+ """
+ return A6ErrCode.BAD_REQUEST
diff --git a/apisix/runner/http/response.py b/apisix/runner/http/response.py
index 4f06034..50dca10 100644
--- a/apisix/runner/http/response.py
+++ b/apisix/runner/http/response.py
@@ -28,226 +28,139 @@ PLUGIN_ACTION_REWRITE = HCAction.Action.Rewrite
class Response:
- def __init__(self, ty: int = 0):
+ def __init__(self):
"""
Init and parse request
- :param ty:
- rpc request protocol type
- """
- self.rpc_type = ty
- self._resp_id = 0
- self._resp_token = 0
- self._resp_body = ""
- self._resp_path = ""
- self._resp_args = {}
- self._resp_headers = {}
- self._resp_status_code = 0
- self._resp_error_code = 0
- self._resp_action_type = 0
-
- @property
- def rpc_type(self) -> int:
- """
- get protocol type for response handler
- :return:
- """
- return self._rpc_type
-
- @rpc_type.setter
- def rpc_type(self, rpc_type: int) -> None:
- """
- set protocol type for response handler
- :return:
- """
- self._rpc_type = rpc_type
-
- @property
- def id(self) -> int:
- """
- get request id for response handler
- :return:
- """
- return self._resp_id
-
- @id.setter
- def id(self, resp_id: int) -> None:
- """
- set request id for response handler
- :return:
- """
- self._resp_id = resp_id
-
- @property
- def token(self) -> int:
"""
- get token for response handler
- :return:
- """
- return self._resp_token
- @token.setter
- def token(self, resp_token: int) -> None:
- """
- set token for response handler
- :return:
- """
- self._resp_token = resp_token
+ # response attribute
+ self.__body = ""
+ self.__headers = {}
+ self.__status_code = 0
- @property
- def body(self) -> str:
- """
- get body for response handler
- :return:
- """
- return self._resp_body
+ # custom attribute
+ self.__req_id = 0
- @body.setter
- def body(self, resp_body: str) -> None:
+ def get_header(self, key: str) -> str:
"""
- set body for response handler
+ get response header
+ :param key:
:return:
"""
- self._resp_body = resp_body
+ return self.__headers.get(key)
- @property
- def path(self) -> str:
+ def set_header(self, key: str, value: str) -> bool:
"""
- get path for response handler
+ set response header
+ :param key:
+ :param value:
:return:
"""
- return self._resp_path
-
- @path.setter
- def path(self, resp_path: str) -> None:
- """
- set path for response handler
- :return:
- """
- self._resp_path = resp_path
-
- @property
- def args(self) -> dict:
- """
- get args for response handler
- :return:
- """
- return self._resp_args
-
- @args.setter
- def args(self, resp_args: dict) -> None:
- """
- set args for response handler
- :return:
- """
- self._resp_args = resp_args
-
- @property
- def headers(self) -> dict:
- """
- get headers for response handler
- :return:
- """
- return self._resp_headers
+ if key and value:
+ self.__headers[key] = value
+ return True
+ return False
- @headers.setter
- def headers(self, resp_headers: dict) -> None:
+ def get_headers(self) -> dict:
"""
- set headers for response handler
+ get response headers
:return:
"""
- self._resp_headers = resp_headers
+ return self.__headers
- @property
- def status_code(self) -> int:
+ def set_headers(self, headers: dict) -> bool:
"""
- get status code for response handler
+ get response headers
+ :param headers:
:return:
"""
- return self._resp_status_code
+ if headers:
+ self.__headers = headers
+ return True
+ return False
- @status_code.setter
- def status_code(self, resp_status_code: int) -> None:
+ def get_body(self) -> str:
"""
- set status code for response handler
+ get response body
:return:
"""
- self._resp_status_code = resp_status_code
+ return self.__body
- @property
- def error_code(self) -> int:
+ def set_body(self, body: str) -> bool:
"""
- get error code for response handler
+ get response body
:return:
"""
- return self._resp_error_code
+ if body:
+ self.__body = body
+ return True
+ return False
- @error_code.setter
- def error_code(self, resp_error_code: int = 0) -> None:
+ def get_status_code(self) -> int:
"""
- set error code for response handler
+ get response status code
:return:
"""
- self._resp_error_code = resp_error_code
+ return self.__status_code or 200
- @property
- def action_type(self):
+ def set_status_code(self, status_code: int) -> bool:
"""
- get action type for response handler
+ set response status code
+ :param status_code:
:return:
"""
- return self._resp_action_type
+ if status_code and (100 <= status_code <= 599):
+ self.__status_code = status_code
+ return True
+ return False
- @action_type.setter
- def action_type(self, action_type: int = 0) -> None:
+ def get_req_id(self) -> int:
"""
- set action type for response handler
- :param action_type:
+ get request id
:return:
"""
- self._resp_action_type = action_type
+ return self.__req_id
- def reset(self) -> None:
+ def set_req_id(self, req_id: int) -> bool:
"""
- reset response handler
+ set request id
+ :param req_id:
:return:
"""
- self._rpc_type = 0
- self._resp_id = 0
- self._resp_token = 0
- self._resp_body = ""
- self._resp_path = ""
- self._resp_args = {}
- self._resp_headers = {}
- self._resp_status_code = 0
- self._resp_error_code = 0
- self._resp_action_type = 0
+ if req_id:
+ self.__req_id = req_id
+ return True
+ return False
def changed(self) -> bool:
"""
check response handler is change
:return:
"""
- if self.body or self.headers or self.status_code or self.token or
self.error_code:
+ if self.__body or self.__headers or self.__status_code:
return True
else:
return False
@runner_utils.response_call(HCAction.Action.Stop)
def call_handler(self, builder: flatbuffers.Builder):
+ """
+ get http call response
+ :param builder:
+ :return:
+ """
if not self.changed():
return None, 0
- headers_vector = runner_utils.create_dict_vector(builder,
self.headers, HCAction.Action.Stop,
+ headers_vector = runner_utils.create_dict_vector(builder,
self.get_headers(), HCAction.Action.Stop,
runner_utils.VECTOR_TYPE_HEADER)
- body_vector = runner_utils.create_str_vector(builder, self.body)
+ body_vector = runner_utils.create_str_vector(builder, self.get_body())
- status_code = 200
- if self.status_code > 0:
- status_code = self.status_code
+ status_code = self.get_status_code()
HCStop.StopStart(builder)
HCStop.StopAddStatus(builder, status_code)
HCStop.StopAddBody(builder, body_vector)
HCStop.StopAddHeaders(builder, headers_vector)
stop = HCStop.StopEnd(builder)
- return stop, self.id
+ return stop, self.get_req_id()
diff --git a/apisix/runner/server/handle.py b/apisix/runner/server/handle.py
index 9f43719..40e10d8 100644
--- a/apisix/runner/server/handle.py
+++ b/apisix/runner/server/handle.py
@@ -44,7 +44,7 @@ class Handle:
# generate token
token = runner_cache.generate_token()
# get plugins config
- configs = req.configs
+ configs = req.get_configs()
# cache plugins config
ok = runner_cache.set_config_by_token(token, configs)
if not ok:
@@ -53,7 +53,7 @@ class Handle:
req.unknown_handler(builder)
return builder
- req.conf_token = token
+ req.set_conf_token(token)
ok = req.config_handler(builder)
if not ok:
self.r.log.error("prepare conf request failure")
@@ -65,7 +65,7 @@ class Handle:
elif self.r.request.ty == runner_utils.RPC_HTTP_REQ_CALL:
# get request token
- token = req.conf_token
+ token = req.get_conf_token()
# get plugins
configs = runner_cache.get_config_by_token(token)
@@ -76,8 +76,8 @@ class Handle:
return builder
# init response
- resp = NewHttpResponse(self.r.request.ty)
- resp.id = req.id
+ resp = NewHttpResponse()
+ resp.set_req_id(req.get_id())
# execute plugins
ok = runner_plugin.execute(configs, self.r, req, resp)
diff --git a/tests/runner/http/test_request.py
b/tests/runner/http/test_request.py
index b63736d..6900575 100644
--- a/tests/runner/http/test_request.py
+++ b/tests/runner/http/test_request.py
@@ -42,10 +42,10 @@ def test_request_config_handler():
r = default_request()
req = RunnerHttpRequest(r)
- req.conf_token = 0
+ req.set_conf_token(0)
ok = req.config_handler(builder)
assert not ok
- req.conf_token = 1
+ req.set_conf_token(1)
ok = req.config_handler(builder)
assert ok
@@ -54,53 +54,75 @@ def test_request_call_handler():
builder = runner_utils.new_builder()
r = default_request()
req = RunnerHttpRequest(r)
- req.path = ""
- req.headers = {}
- req.args = {}
+ req.set_uri("")
+ req.set_headers({})
+ req.set_args({})
ok = req.call_handler(builder)
assert not ok
- req.headers["X-Hello"] = "World"
- req.id = 1
+ req.set_header("X-Hello", "World")
+ req.set_id(1)
ok = req.call_handler(builder)
assert ok
- req.path = "/hello"
+ req.set_uri("/hello")
+ req.set_id(1)
ok = req.call_handler(builder)
assert ok
def test_request_handler():
+ default_key = "hello"
+ default_val = "world"
+ default_empty_str = ""
+ default_empty_dict = {}
+ default_id = 1000
+ default_token = 1
+ default_uri = "/hello"
+ default_method = "GET"
+ default_ip = "127.0.0.1"
+
r = default_request()
req = RunnerHttpRequest(r)
- req.id = 1000
- assert req.id == 1000
- req.rpc_type = runner_utils.RPC_UNKNOWN
- assert req.rpc_type == runner_utils.RPC_UNKNOWN
- req.rpc_buf = b'hello'
- assert req.rpc_buf == b'hello'
- req.conf_token = 10
- assert req.conf_token == 10
- req.method = "GET"
- assert req.method == "GET"
- req.path = "/hello"
- assert req.path == "/hello"
- req.headers = {"X-HELLO": "Python"}
- assert req.headers == {"X-HELLO": "Python"}
- req.configs = {"hello": "Python"}
- assert req.configs == {"hello": "Python"}
- req.args = {"hello": "Python"}
- assert req.args == {"hello": "Python"}
- req.src_ip = "127.0.0.1"
- assert req.src_ip == "127.0.0.1"
- req.err_code = 400
- assert req.err_code == 400
- req.reset()
- assert req.rpc_type == 0
- assert req.rpc_buf == b''
- assert req.id == 0
- assert req.conf_token == 0
- assert req.method == ""
- assert req.path == ""
- assert req.headers == {}
- assert req.configs == {}
- assert req.args == {}
- assert req.src_ip == ""
+
+ assert not req.set_id(0)
+ assert req.set_id(default_id)
+ assert req.get_id() == default_id
+
+ assert not req.set_conf_token(0)
+ assert req.set_conf_token(default_token)
+ assert req.get_conf_token() == default_token
+
+ assert not req.set_method(default_key)
+ assert req.set_method(default_method)
+ assert req.get_method() == default_method
+
+ assert not req.set_uri(default_key)
+ assert req.set_uri(default_uri)
+ assert req.get_uri() == default_uri
+
+ assert not req.set_header(default_key, default_empty_str)
+ assert req.set_header(default_key, default_val)
+ assert req.get_header(default_key) == default_val
+
+ assert not req.set_headers(default_empty_dict)
+ assert req.set_headers({default_key: default_val})
+ assert req.get_headers() == {default_key: default_val}
+
+ assert not req.set_config(default_key, default_empty_str)
+ assert req.set_config(default_key, default_val)
+ assert req.get_config(default_key) == default_val
+
+ assert not req.set_configs(default_empty_dict)
+ assert req.set_configs({default_key: default_val})
+ assert req.get_configs() == {default_key: default_val}
+
+ assert not req.set_arg(default_key, default_empty_str)
+ assert req.set_arg(default_key, default_val)
+ assert req.get_arg(default_key) == default_val
+
+ assert not req.set_args(default_empty_dict)
+ assert req.set_args({default_key: default_val})
+ assert req.get_args() == {default_key: default_val}
+
+ assert not req.set_remote_addr(default_empty_str)
+ assert req.set_remote_addr(default_ip)
+ assert req.get_remote_addr() == default_ip
diff --git a/tests/runner/http/test_response.py
b/tests/runner/http/test_response.py
index 50689fa..c9e3004 100644
--- a/tests/runner/http/test_response.py
+++ b/tests/runner/http/test_response.py
@@ -22,44 +22,41 @@ from apisix.runner.http.response import Response as
RunnerHttpResponse
def test_response_call_handler():
builder = runner_utils.new_builder()
resp = RunnerHttpResponse()
- resp.id = 1
+ resp.set_req_id(1)
ok = resp.call_handler(builder)
assert not ok
- resp.body = "Hello Python Runner"
+ resp.set_body("Hello Python Runner")
ok = resp.call_handler(builder)
assert ok
def test_response_handler():
+ default_key = "hello"
+ default_val = "world"
+ default_empty_str = ""
+ default_empty_dict = {}
+ default_num_zero = 0
+ default_id = 1000
+ default_code = 200
+
resp = RunnerHttpResponse()
- resp.rpc_type = runner_utils.RPC_UNKNOWN
- assert resp.rpc_type == runner_utils.RPC_UNKNOWN
- resp.token = 1000
- assert resp.token == 1000
- resp.headers = {"X-HELLO": "Python"}
- assert resp.headers == {"X-HELLO": "Python"}
- resp.body = "Hello, Python"
- assert resp.body == "Hello, Python"
- resp.args = {"hello": "Python"}
- assert resp.args == {"hello": "Python"}
- resp.path = "/hello"
- assert resp.path == "/hello"
- resp.id = 1000
- assert resp.id == 1000
- resp.status_code = 200
- assert resp.status_code == 200
- resp.error_code = 1
- assert resp.error_code == 1
- resp.action_type = 10
- assert resp.action_type == 10
- resp.reset()
- assert resp.rpc_type == 0
- assert resp.id == 0
- assert resp.token == 0
- assert resp.body == ""
- assert resp.path == ""
- assert resp.args == {}
- assert resp.headers == {}
- assert resp.status_code == 0
- assert resp.error_code == 0
- assert resp.action_type == 0
+
+ assert not resp.set_header(default_key, default_empty_str)
+ assert resp.set_header(default_key, default_val)
+ assert resp.get_header(default_key) == default_val
+
+ assert not resp.set_headers(default_empty_dict)
+ assert resp.set_headers({default_key: default_val})
+ assert resp.get_headers() == {default_key: default_val}
+
+ assert not resp.set_body(default_empty_str)
+ assert resp.set_body(default_val)
+ assert resp.get_body() == default_val
+
+ assert not resp.set_req_id(0)
+ assert resp.set_req_id(default_id)
+ assert resp.get_req_id() == default_id
+
+ assert not resp.set_status_code(default_num_zero)
+ assert resp.set_status_code(default_code)
+ assert resp.get_status_code() == default_code
