def __init__(self, session, rspec, test_block_config):
"""Prepare request
Args:
rspec (dict): test spec
test_block_config (dict): Any configuration for this the block of
tests
Raises:
UnexpectedKeysError: If some unexpected keys were used in the test
spec. Only valid keyword args to requests can be passed
"""
if 'meta' in rspec:
meta = rspec.pop('meta')
if meta and 'clear_session_cookies' in meta:
session.cookies.clear_session_cookies()
expected = {
"method",
"url",
"headers",
"data",
"params",
"auth",
"json",
"verify",
"files",
"stream",
"timeout",
# "cookies",
# "hooks",
}
check_expected_keys(expected, rspec)
request_args = get_request_args(rspec, test_block_config)
logger.debug("Request args: %s", request_args)
request_args.update(allow_redirects=False)
self._request_args = request_args
# There is no way using requests to make a prepared request that will
# not follow redirects, so instead we have to do this. This also means
# that we can't have the 'pre-request' hook any more because we don't
# create a prepared request.
def prepared_request():
# If there are open files, create a context manager around each so
# they will be closed at the end of the request.
with ExitStack() as stack:
for key, filepath in self._request_args.get("files",
{}).items():
self._request_args["files"][key] = stack.enter_context(
open(filepath, "rb"))
return session.request(**self._request_args)
self._prepared = prepared_request
def __init__(self, client, rspec, test_block_config):
expected = {"topic", "payload", "json", "qos", "retain"}
check_expected_keys(expected, rspec)
publish_args = get_publish_args(rspec, test_block_config)
self._prepared = functools.partial(client.publish, **publish_args)
# Need to do this here because get_publish_args will modify the original
# input, which we might want to use to format. No error handling because
# all the error handling is done in the previous call
self._original_publish_args = format_keys(rspec, test_block_config["variables"])
def __init__(self, session, rspec, test_block_config):
"""Prepare request
Args:
rspec (dict): test spec
test_block_config (dict): Any configuration for this the block of
tests
Raises:
UnexpectedKeysError: If some unexpected keys were used in the test
spec. Only valid keyword args to requests can be passed
"""
if 'meta' in rspec:
meta = rspec.pop('meta')
if meta and 'clear_session_cookies' in meta:
session.cookies.clear_session_cookies()
expected = {
"method",
"url",
"headers",
"data",
"params",
"auth",
"json",
"verify",
# "files",
# "cookies",
# "hooks",
}
check_expected_keys(expected, rspec)
request_args = get_request_args(rspec, test_block_config)
logger.debug("Request args: %s", request_args)
request_args.update(allow_redirects=False)
self._request_args = request_args
# There is no way using requests to make a prepared request that will
# not follow redicrects, so instead we have to do this. This also means
# that we can't have the 'pre-request' hook any more because we don't
# create a prepared request.
self._prepared = functools.partial(session.request, **request_args)
def __init__(self, session, rspec, test_block_config):
"""Prepare request
Args:
rspec (dict): test spec
test_block_config (dict): Any configuration for this the block of
tests
Raises:
UnexpectedKeysError: If some unexpected keys were used in the test
spec. Only valid keyword args to requests can be passed
"""
if 'meta' in rspec:
meta = rspec.pop('meta')
if meta and 'clear_session_cookies' in meta:
# TODO: how to clear cookies?
#session.cookies.clear_session_cookies()
pass
expected = {
"method",
"url",
"headers",
"data",
"params",
"auth",
"json",
"verify",
# "files",
# "cookies",
# "hooks",
}
check_expected_keys(expected, rspec)
request_args = get_request_args(rspec, test_block_config)
logger.debug("Request args: %s", request_args)
self._request_args = request_args
# TODO: Follow redirects options?
self._prepared = functools.partial(session.make_request, **request_args)
def __init__(self, **kwargs):
expected_blocks = {
"app": {
"location",
},
}
check_expected_keys(expected_blocks.keys(), kwargs)
try:
self._app_args = kwargs.pop("app", {})
app_location = self._app_args["location"]
except KeyError as e:
msg = "Need to specify app location (in the form my.module:application)"
logger.error(msg)
raise_from(exceptions.MissingKeysError(msg), e)
self._flask_app = import_ext_function(app_location)
self._test_client = self._flask_app.test_client()
def __init__(self, **kwargs):
expected_blocks = {
"client": {
"client_id",
"clean_session",
# Can't really use this easily...
# "userdata",
# Force mqttv311 - fix if this becomes an issue
# "protocol",
"transport",
},
"connect": {
"host",
"port",
"keepalive",
"timeout",
},
"tls": {
"enable",
"ca_certs",
"cert_reqs",
"certfile",
"keyfile",
"tls_version",
"ciphers",
},
"auth": {
"username",
"password",
},
}
logger.debug("Initialising MQTT client with %s", kwargs)
# check main block first
check_expected_keys(expected_blocks.keys(), kwargs)
# then check constructor/connect/tls_set args
self._client_args = kwargs.pop("client", {})
check_expected_keys(expected_blocks["client"], self._client_args)
self._connect_args = kwargs.pop("connect", {})
check_expected_keys(expected_blocks["connect"], self._connect_args)
self._auth_args = kwargs.pop("auth", {})
check_expected_keys(expected_blocks["auth"], self._auth_args)
if "host" not in self._connect_args:
msg = "Need 'host' in 'connect' block for mqtt"
logger.error(msg)
raise exceptions.MissingKeysError(msg)
self._connect_timeout = self._connect_args.pop("timeout", 3)
# If there is any tls kwarg (including 'enable'), enable tls
self._tls_args = kwargs.pop("tls", {})
check_expected_keys(expected_blocks["tls"], self._tls_args)
self._handle_tls_args()
logger.debug("TLS is %s",
"enabled" if self._enable_tls else "disabled")
logger.debug("Paho client args: %s", self._client_args)
self._client = paho.Client(**self._client_args)
self._client.enable_logger()
if self._auth_args:
self._client.username_pw_set(**self._auth_args)
self._client.on_message = self._on_message
if self._enable_tls:
try:
self._client.tls_set(**self._tls_args)
except ValueError as e:
# tls_set only raises ValueErrors directly
raise_from(
exceptions.MQTTTLSError("Unexpected error enabling TLS",
e))
except ssl.SSLError as e:
# incorrect cipher, etc.
raise_from(
exceptions.MQTTTLSError(
"Unexpected SSL error enabling TLS", e))
# Arbitrary number, could just be 1 and only accept 1 message per stages
# but we might want to raise an error if more than 1 message is received
# during a test stage.
self._message_queue = Queue(maxsize=10)
self._userdata = {
"queue": self._message_queue,
}
self._client.user_data_set(self._userdata)
def __init__(self, session, rspec, test_block_config):
"""Prepare request
Args:
session (requests.Session): existing session
rspec (dict): test spec
test_block_config (dict): Any configuration for this the block of
tests
Raises:
UnexpectedKeysError: If some unexpected keys were used in the test
spec. Only valid keyword args to requests can be passed
"""
if "meta" in rspec:
meta = rspec.pop("meta")
if meta and "clear_session_cookies" in meta:
session.cookies.clear_session_cookies()
expected = {
"method",
"url",
"headers",
"data",
"params",
"auth",
"json",
"verify",
"files",
"file_body",
"stream",
"timeout",
"cookies",
"cert",
# "hooks",
"follow_redirects",
}
check_expected_keys(expected, rspec)
request_args = get_request_args(rspec, test_block_config)
update_from_ext(
request_args,
RestRequest.optional_in_file,
test_block_config,
)
# Used further down, but pop it asap to avoid unwanted side effects
file_body = request_args.pop("file_body", None)
# If there was a 'cookies' key, set it in the request
expected_cookies = _read_expected_cookies(session, rspec, test_block_config)
if expected_cookies is not None:
logger.debug("Sending cookies %s in request", expected_cookies.keys())
request_args.update(cookies=expected_cookies)
# Check for redirects
request_args.update(
allow_redirects=_check_allow_redirects(rspec, test_block_config)
)
logger.debug("Request args: %s", request_args)
self._request_args = request_args
# There is no way using requests to make a prepared request that will
# not follow redirects, so instead we have to do this. This also means
# that we can't have the 'pre-request' hook any more because we don't
# create a prepared request.
def prepared_request():
# If there are open files, create a context manager around each so
# they will be closed at the end of the request.
with ExitStack() as stack:
stack.enter_context(_set_cookies_for_request(session, request_args))
# These are mutually exclusive
if file_body:
file = stack.enter_context(open(file_body, "rb"))
request_args.update(data=file)
else:
self._request_args.update(
_get_file_arguments(request_args, stack, test_block_config)
)
return session.request(**self._request_args)
self._prepared = prepared_request
def __init__(self, session, rspec, test_block_config):
"""Prepare request
Args:
session (requests.Session): existing session
rspec (dict): test spec
test_block_config (dict): Any configuration for this the block of
tests
Raises:
UnexpectedKeysError: If some unexpected keys were used in the test
spec. Only valid keyword args to requests can be passed
"""
if "meta" in rspec:
meta = rspec.pop("meta")
if meta and "clear_session_cookies" in meta:
session.cookies.clear_session_cookies()
expected = {
"method",
"url",
"headers",
"data",
"params",
"auth",
"json",
"verify",
"files",
"stream",
"timeout",
"cookies",
"cert",
# "hooks",
}
check_expected_keys(expected, rspec)
request_args = get_request_args(rspec, test_block_config)
# Need to do this down here - it is separate from getting request args as
# it depends on the state of the session
if "cookies" in rspec:
existing_cookies = session.cookies.get_dict()
missing = set(rspec["cookies"]) - set(existing_cookies.keys())
if missing:
logger.error("Missing cookies")
raise exceptions.MissingCookieError(
"Tried to use cookies '{}' in request but only had '{}' available"
.format(rspec["cookies"], existing_cookies))
request_args["cookies"] = {
c: existing_cookies.get(c)
for c in rspec["cookies"]
}
logger.debug("Request args: %s", request_args)
request_args.update(allow_redirects=False)
self._request_args = request_args
# There is no way using requests to make a prepared request that will
# not follow redirects, so instead we have to do this. This also means
# that we can't have the 'pre-request' hook any more because we don't
# create a prepared request.
def prepared_request():
# If there are open files, create a context manager around each so
# they will be closed at the end of the request.
with ExitStack() as stack:
stack.enter_context(
_set_cookies_for_request(session, request_args))
self._request_args.update(self._get_file_arguments(stack))
return session.request(**self._request_args)
self._prepared = prepared_request
