def _get_request_path(self, request, scenario):
parsed_url = parse.urlparse(request.url)
if not self._target.get("scheme"):
self._target["scheme"] = parsed_url.scheme
if not self._target.get("netloc"):
self._target["netloc"] = parsed_url.netloc
if parsed_url.scheme != self._target["scheme"] or parsed_url.netloc != self._target["netloc"]:
raise ValueError("Address port and host must be the same")
path = parsed_url.path
if parsed_url.query:
path += "?" + parsed_url.query
else:
if request.method == "GET" and isinstance(request.body, dict):
path += "?" + urlencode(request.body)
if not parsed_url.netloc:
parsed_url = parse.urlparse(scenario.get("default-address", ""))
self.hostname = parsed_url.netloc.split(':')[0] if ':' in parsed_url.netloc else parsed_url.netloc
self.use_ssl = parsed_url.scheme == 'https'
if parsed_url.port:
self.port = parsed_url.port
else:
self.port = 443 if self.use_ssl else 80
return path if len(path) else '/'
def _get_request_path(self, request, scenario):
parsed_url = parse.urlparse(request.url)
if not self._target.get("scheme"):
self._target["scheme"] = parsed_url.scheme
if not self._target.get("netloc"):
self._target["netloc"] = parsed_url.netloc
if parsed_url.scheme != self._target[
"scheme"] or parsed_url.netloc != self._target["netloc"]:
raise TaurusConfigError("Address port and host must be the same")
path = parsed_url.path
if parsed_url.query:
path += "?" + parsed_url.query
else:
if request.method == "GET" and isinstance(request.body, dict):
path += "?" + urlencode(request.body)
if not parsed_url.netloc:
parsed_url = parse.urlparse(scenario.get("default-address", ""))
self.hostname = parsed_url.netloc.split(
':')[0] if ':' in parsed_url.netloc else parsed_url.netloc
self.use_ssl = parsed_url.scheme == 'https'
if parsed_url.port:
self.port = parsed_url.port
else:
self.port = 443 if self.use_ssl else 80
return path if len(path) else '/'
def __gen_servers(self, scenario):
default_address = scenario.get("default-address", None)
if default_address is None:
requests = list(scenario.get_requests())
if not requests:
raise ValueError("No requests provided in scenario")
base_addr = parse.urlparse(requests[0].url)
self.log.debug("default-address was not specified, using %s insted", base_addr.hostname)
else:
base_addr = parse.urlparse(default_address)
servers = etree.Element("servers")
port = base_addr.port if base_addr.port is not None else 80
server = etree.Element("server", host=base_addr.hostname, port=str(port), type="tcp")
servers.append(server)
return servers
def __gen_servers(self, scenario):
default_address = scenario.get("default-address", None)
if default_address is None:
requests = list(scenario.get_requests())
if not requests:
raise ValueError("No requests provided in scenario")
base_addr = parse.urlparse(requests[0].url)
self.log.debug("default-address was not specified, using %s instead", base_addr.hostname)
else:
base_addr = parse.urlparse(default_address)
servers = etree.Element("servers")
port = base_addr.port if base_addr.port is not None else 80
server = etree.Element("server", host=base_addr.hostname, port=str(port), type="tcp")
servers.append(server)
return servers
def __gen_servers(self, scenario):
default_address = scenario.get("default-address")
if default_address:
base_addr = parse.urlparse(default_address)
else:
first_request = self.__first_http_request(scenario)
if not first_request:
raise TaurusConfigError("Tsung: you must specify requests in scenario")
base_addr = parse.urlparse(first_request.url)
self.log.debug("default-address was not specified, using %s instead", base_addr.hostname)
servers = etree.Element("servers")
port = base_addr.port if base_addr.port is not None else 80
server = etree.Element("server", host=base_addr.hostname, port=str(port), type="tcp")
servers.append(server)
return servers
def find_file(self, filename):
"""
Try to find file in search_path if it was specified. Helps finding files
in non-CLI environments or relative to config path
:param filename: file basename to find
"""
filename = os.path.expanduser(filename)
if os.path.isfile(filename):
return filename
elif filename.lower().startswith("http://") or filename.lower().startswith("https://"):
parsed_url = parse.urlparse(filename)
downloader = request.FancyURLopener()
self.log.info("Downloading %s", filename)
tmp_f_name, http_msg = downloader.retrieve(filename)
cd_header = http_msg.get('Content-Disposition', '')
dest = cd_header.split('filename=')[-1] if cd_header and 'filename=' in cd_header else ''
if not dest:
dest = os.path.basename(parsed_url.path)
fname, ext = os.path.splitext(dest) if dest else (parsed_url.hostname.replace(".", "_"), '.file')
dest = self.create_artifact(fname, ext)
self.log.debug("Moving %s to %s", tmp_f_name, dest)
shutil.move(tmp_f_name, dest)
return dest
elif self.file_search_paths:
for dirname in self.file_search_paths:
location = os.path.join(dirname, os.path.basename(filename))
if os.path.isfile(location):
self.log.warning("Guessed location from search paths for file %s: %s", filename, location)
return location
self.log.warning("Could not find file at path: %s", filename)
return filename
def find_file(self, filename):
"""
Try to find file or dir in search_path if it was specified. Helps finding files
in non-CLI environments or relative to config path
:param filename: file basename to find
:type filename: str
"""
if not filename:
return filename
filename = os.path.expanduser(filename)
if os.path.exists(filename):
return filename
elif filename.lower().startswith("http://") or filename.lower().startswith("https://"):
parsed_url = parse.urlparse(filename)
downloader = request.FancyURLopener()
self.log.info("Downloading %s", filename)
tmp_f_name, http_msg = downloader.retrieve(filename)
cd_header = http_msg.get('Content-Disposition', '')
dest = cd_header.split('filename=')[-1] if cd_header and 'filename=' in cd_header else ''
if not dest:
dest = os.path.basename(parsed_url.path)
fname, ext = os.path.splitext(dest) if dest else (parsed_url.hostname.replace(".", "_"), '.file')
dest = self.create_artifact(fname, ext)
self.log.debug("Moving %s to %s", tmp_f_name, dest)
shutil.move(tmp_f_name, dest)
return dest
elif self.file_search_paths:
for dirname in self.file_search_paths:
location = os.path.join(dirname, os.path.basename(filename))
if os.path.exists(location):
self.log.warning("Guessed location from search paths for %s: %s", filename, location)
return location
self.log.warning("Could not find location at path: %s", filename)
return filename
def _get_http_request(url, label, method, timeout, body, keepalive):
"""
Generates HTTP request
:type method: str
:type label: str
:type url: str
:rtype: lxml.etree.Element
"""
proxy = etree.Element("HTTPSamplerProxy", guiclass="HttpTestSampleGui", testclass="HTTPSamplerProxy")
proxy.set("testname", label)
args = JMX._get_arguments_panel("HTTPsampler.Arguments")
if isinstance(body, string_types):
proxy.append(JMX._bool_prop("HTTPSampler.postBodyRaw", True))
coll_prop = JMX._collection_prop("Arguments.arguments")
header = JMX._element_prop("elementProp", "HTTPArgument")
header.append(JMX._string_prop("Argument.value", body))
coll_prop.append(header)
args.append(coll_prop)
proxy.append(args)
elif isinstance(body, dict):
http_args_coll_prop = JMX._collection_prop("Arguments.arguments")
for arg_name, arg_value in body.items():
http_element_prop = JMX._element_prop(arg_name, "HTTPArgument")
http_element_prop.append(JMX._bool_prop("HTTPArgument.always_encode", True))
http_element_prop.append(JMX._bool_prop("HTTPArgument.use_equals", arg_value is not None))
http_element_prop.append(JMX._string_prop("Argument.value", arg_value if arg_value is not None else ''))
http_element_prop.append(JMX._string_prop("Argument.name", arg_name))
http_element_prop.append(JMX._string_prop("Argument.metadata", '='))
http_args_coll_prop.append(http_element_prop)
args.append(http_args_coll_prop)
proxy.append(args)
elif body:
raise ValueError("Cannot handle 'body' option of type %s: %s" % (type(body), body))
parsed_url = parse.urlparse(url)
if parsed_url.scheme:
proxy.append(JMX._string_prop("HTTPSampler.protocol", parsed_url.scheme))
if parsed_url.hostname:
proxy.append(JMX._string_prop("HTTPSampler.domain", parsed_url.hostname))
if parsed_url.port:
proxy.append(JMX._string_prop("HTTPSampler.port", parsed_url.port))
path = parsed_url.path
if parsed_url.query:
path += "?" + parsed_url.query
proxy.append(JMX._string_prop("HTTPSampler.path", path))
proxy.append(JMX._string_prop("HTTPSampler.method", method))
proxy.append(JMX._bool_prop("HTTPSampler.use_keepalive", keepalive))
proxy.append(JMX._bool_prop("HTTPSampler.follow_redirects", True))
if timeout is not None:
proxy.append(JMX._string_prop("HTTPSampler.connect_timeout", timeout))
proxy.append(JMX._string_prop("HTTPSampler.response_timeout", timeout))
return proxy
def _add_url_request(self, default_address, req, test_method):
parsed_url = parse.urlparse(req.url)
if default_address is not None and not parsed_url.netloc:
url = default_address + req.url
else:
url = req.url
if req.timeout is not None:
test_method.append(self.gen_impl_wait(req.timeout))
test_method.append(self.gen_statement("self.driver.get('%s')" % url))
def _get_http_request(url, label, method, timeout, body, keepalive, files=(), encoding=None, follow_redirects=True):
"""
Generates HTTP request
:type method: str
:type label: str
:type url: str
:rtype: lxml.etree.Element
"""
proxy = etree.Element("HTTPSamplerProxy", guiclass="HttpTestSampleGui", testclass="HTTPSamplerProxy")
proxy.set("testname", label)
args = JMX._get_arguments_panel("HTTPsampler.Arguments")
if isinstance(body, string_types):
JMX.__add_body_from_string(args, body, proxy)
elif isinstance(body, dict):
JMX.__add_body_from_script(args, body, proxy)
elif body:
msg = "Cannot handle 'body' option of type %s: %s"
raise TaurusInternalException(msg % (type(body), body))
parsed_url = parse.urlparse(url)
JMX.__add_hostnameport_2sampler(parsed_url, proxy, url)
path = parsed_url.path
if parsed_url.query:
path += "?" + parsed_url.query
proxy.append(JMX._string_prop("HTTPSampler.path", path))
proxy.append(JMX._string_prop("HTTPSampler.method", method))
proxy.append(JMX._bool_prop("HTTPSampler.use_keepalive", keepalive))
proxy.append(JMX._bool_prop("HTTPSampler.follow_redirects", follow_redirects))
proxy.append(JMX._bool_prop("HTTPSampler.auto_redirects", False))
if timeout is not None:
proxy.append(JMX._string_prop("HTTPSampler.connect_timeout", timeout))
proxy.append(JMX._string_prop("HTTPSampler.response_timeout", timeout))
if encoding is not None:
proxy.append(JMX._string_prop("HTTPSampler.contentEncoding", encoding))
if files:
proxy.append(JMX._bool_prop("HTTPSampler.DO_MULTIPART_POST", True))
proxy.append(JMX._bool_prop("HTTPSampler.BROWSER_COMPATIBLE_MULTIPART", True))
files_prop = JMX._element_prop("HTTPsampler.Files", "HTTPFileArgs")
files_coll = JMX._collection_prop("HTTPFileArgs.files")
for file_dict in files:
file_elem = JMX._element_prop(file_dict['path'], "HTTPFileArg")
file_elem.append(JMX._string_prop("File.path", file_dict['path']))
file_elem.append(JMX._string_prop("File.paramname", file_dict["param"]))
file_elem.append(JMX._string_prop("File.mimetype", file_dict['mime-type']))
files_coll.append(file_elem)
files_prop.append(files_coll)
proxy.append(files_prop)
return proxy
def build_source_code(self):
self.log.debug("Generating Test Case test methods")
imports = self.add_imports()
self.root.append(imports)
test_class = self.gen_class_definition("TestRequests", ["unittest.TestCase"])
self.root.append(test_class)
test_class.append(self.gen_setupclass_method())
test_class.append(self.gen_teardownclass_method())
counter = 0
methods = {}
requests = self.scenario.get_requests()
scenario_timeout = self.scenario.get("timeout", 30)
default_address = self.scenario.get("default-address", None)
for req in requests:
if req.label:
label = req.label
else:
label = req.url
mod_label = re.sub('[^0-9a-zA-Z]+', '_', label[:30])
method_name = 'test_%05d_%s' % (counter, mod_label)
test_method = self.gen_test_method(method_name)
methods[method_name] = label
counter += 1
test_class.append(test_method)
parsed_url = parse.urlparse(req.url)
if default_address is not None and not parsed_url.netloc:
url = default_address + req.url
else:
url = req.url
test_method.append(self.gen_comment("start request: %s" % url))
if req.timeout is not None:
test_method.append(self.gen_impl_wait(req.timeout))
test_method.append(self.gen_statement("self.driver.get('%s')" % url))
think_time = req.think_time if req.think_time else self.scenario.get("think-time", None)
if think_time is not None:
test_method.append(self.gen_statement("sleep(%s)" % dehumanize_time(think_time)))
if "assert" in req.config:
test_method.append(self.__gen_assert_page())
for assert_config in req.config.get("assert"):
test_method.extend(self.gen_assertion(assert_config))
if req.timeout is not None:
test_method.append(self.gen_impl_wait(scenario_timeout))
test_method.append(self.gen_comment("end request: %s" % url))
test_method.append(self.gen_new_line())
return methods
def _get_http_request(url, label, method, timeout, body, keepalive, files=()):
"""
Generates HTTP request
:type method: str
:type label: str
:type url: str
:rtype: lxml.etree.Element
"""
proxy = etree.Element("HTTPSamplerProxy", guiclass="HttpTestSampleGui", testclass="HTTPSamplerProxy")
proxy.set("testname", label)
args = JMX._get_arguments_panel("HTTPsampler.Arguments")
if isinstance(body, string_types):
JMX.__add_body_from_string(args, body, proxy)
elif isinstance(body, dict):
JMX.__add_body_from_script(args, body, proxy)
elif body:
raise ValueError("Cannot handle 'body' option of type %s: %s" % (type(body), body))
parsed_url = parse.urlparse(url)
JMX.__add_hostnameport_2sampler(parsed_url, proxy, url)
path = parsed_url.path
if parsed_url.query:
path += "?" + parsed_url.query
proxy.append(JMX._string_prop("HTTPSampler.path", path))
proxy.append(JMX._string_prop("HTTPSampler.method", method))
proxy.append(JMX._bool_prop("HTTPSampler.use_keepalive", keepalive))
proxy.append(JMX._bool_prop("HTTPSampler.follow_redirects", True))
if timeout is not None:
proxy.append(JMX._string_prop("HTTPSampler.connect_timeout", timeout))
proxy.append(JMX._string_prop("HTTPSampler.response_timeout", timeout))
if files:
proxy.append(JMX._bool_prop("HTTPSampler.DO_MULTIPART_POST", True))
proxy.append(JMX._bool_prop("HTTPSampler.BROWSER_COMPATIBLE_MULTIPART", True))
files_prop = JMX._element_prop("HTTPsampler.Files", "HTTPFileArgs")
files_coll = JMX._collection_prop("HTTPFileArgs.files")
for file_dict in files:
file_elem = JMX._element_prop(file_dict['path'], "HTTPFileArg")
file_elem.append(JMX._string_prop("File.path", file_dict['path']))
file_elem.append(JMX._string_prop("File.paramname", file_dict["param"]))
file_elem.append(JMX._string_prop("File.mimetype", file_dict['mime-type']))
files_coll.append(file_elem)
files_prop.append(files_coll)
proxy.append(files_prop)
return proxy
def find_file(self, filename):
"""
Try to find file or dir in search_path if it was specified. Helps finding files
in non-CLI environments or relative to config path
Return path is full and mustn't treat with abspath/etc.
:param filename: file basename to find
:type filename: str
"""
if not filename:
return filename
if filename.lower().startswith(
"http://") or filename.lower().startswith("https://"):
parsed_url = parse.urlparse(filename)
downloader = ExceptionalDownloader(self.get_http_client())
self.log.info("Downloading %s", filename)
tmp_f_name, headers = downloader.get(filename)
cd_header = headers.get('Content-Disposition', '')
dest = cd_header.split(
'filename='
)[-1] if cd_header and 'filename=' in cd_header else ''
if dest.startswith('"') and dest.endswith('"') or dest.startswith(
"'") and dest.endswith("'"):
dest = dest[1:-1]
elif not dest:
dest = os.path.basename(parsed_url.path)
fname, ext = os.path.splitext(dest) if dest else (
parsed_url.hostname.replace(".", "_"), '.file')
dest = self.create_artifact(fname, ext)
self.log.debug("Moving %s to %s", tmp_f_name, dest)
shutil.move(tmp_f_name, dest)
return dest
else:
filename = os.path.expanduser(
filename
) # expanding of '~' is required for check of existence
# check filename 'as is' and all combinations of file_search_path/filename
for dirname in [""] + self.file_search_paths:
location = os.path.join(dirname, filename)
if os.path.exists(location):
if dirname:
self.log.warning(
"Guessed location from search paths for %s: %s",
filename, location)
return get_full_path(location)
self.log.warning("Could not find location at path: %s", filename)
return filename
def gen_test_case(self):
self.log.debug("Generating Test Case test method")
imports = self.add_imports()
self.root.append(imports)
test_class = self.gen_class_definition("TestRequests", ["unittest.TestCase"])
self.root.append(test_class)
test_class.append(self.gen_setup_method())
requests = self.scenario.get_requests()
test_method = self.gen_test_method()
test_class.append(test_method)
scenario_timeout = self.scenario.get("timeout", 30)
default_address = self.scenario.get("default-address", None)
for req in requests:
parsed_url = parse.urlparse(req.url)
if default_address is not None and not parsed_url.netloc:
url = default_address + req.url
else:
url = req.url
test_method.append(self.gen_comment("start request: %s" % url))
if req.timeout is not None:
test_method.append(self.gen_impl_wait(req.timeout))
test_method.append(self.gen_method_statement("self.driver.get('%s')" % url))
think_time = req.think_time if req.think_time else self.scenario.get("think-time", None)
if think_time is not None:
test_method.append(self.gen_method_statement("sleep(%s)" % dehumanize_time(think_time)))
if "assert" in req.config:
test_method.append(self.__gen_assert_page())
for assert_config in req.config.get("assert"):
test_method.extend(self.gen_assertion(assert_config))
if req.timeout is not None:
test_method.append(self.gen_impl_wait(scenario_timeout))
test_method.append(self.gen_comment("end request: %s" % url))
test_method.append(self.__gen_new_line())
test_class.append(self.gen_teardown_method())
def _get_http_request(url, label, method, timeout, body, keepalive):
"""
Generates HTTP request
:type method: str
:type label: str
:type url: str
:rtype: lxml.etree.Element
"""
proxy = etree.Element("HTTPSamplerProxy",
guiclass="HttpTestSampleGui",
testclass="HTTPSamplerProxy")
proxy.set("testname", label)
args = JMX._get_arguments_panel("HTTPsampler.Arguments")
if isinstance(body, string_types):
JMX.__add_body_from_string(args, body, proxy)
elif isinstance(body, dict):
JMX.__add_body_from_script(args, body, proxy)
elif body:
raise ValueError("Cannot handle 'body' option of type %s: %s" %
(type(body), body))
parsed_url = parse.urlparse(url)
JMX.__add_hostnameport_2sampler(parsed_url, proxy, url)
path = parsed_url.path
if parsed_url.query:
path += "?" + parsed_url.query
proxy.append(JMX._string_prop("HTTPSampler.path", path))
proxy.append(JMX._string_prop("HTTPSampler.method", method))
proxy.append(JMX._bool_prop("HTTPSampler.use_keepalive", keepalive))
proxy.append(JMX._bool_prop("HTTPSampler.follow_redirects", True))
if timeout is not None:
proxy.append(
JMX._string_prop("HTTPSampler.connect_timeout", timeout))
proxy.append(
JMX._string_prop("HTTPSampler.response_timeout", timeout))
return proxy
def __convert_label_name(url):
"""
http://some.address/path/resource?query -> http.some_address.path.resource.query
:param url:
:return: string
"""
# split url on domain resource, protocol, etc
parsed_url = parse.urlparse(url)
# remove dots from url and join all pieces on dot
# small fix needed - better do not use blank pieces
if parsed_url.scheme:
class_name = parsed_url.scheme + "." + parsed_url.netloc.replace(".", "_")
resource_name = ".".join([parsed_url.path.replace(".", "_"),
parsed_url.params.replace(".", "_"),
parsed_url.query.replace(".", "_"),
parsed_url.fragment.replace(".", "_")])
else:
class_name = url
resource_name = ""
return class_name, resource_name
def find_file(self, filename):
"""
Try to find file or dir in search_path if it was specified. Helps finding files
in non-CLI environments or relative to config path
Return path is full and mustn't treat with abspath/etc.
:param filename: file basename to find
:type filename: str
"""
if not filename:
return filename
if filename.lower().startswith("http://") or filename.lower().startswith("https://"):
parsed_url = parse.urlparse(filename)
downloader = ExceptionalDownloader(self.get_http_client())
self.log.info("Downloading %s", filename)
tmp_f_name, headers = downloader.get(filename)
cd_header = headers.get('Content-Disposition', '')
dest = cd_header.split('filename=')[-1] if cd_header and 'filename=' in cd_header else ''
if dest.startswith('"') and dest.endswith('"') or dest.startswith("'") and dest.endswith("'"):
dest = dest[1:-1]
elif not dest:
dest = os.path.basename(parsed_url.path)
fname, ext = os.path.splitext(dest) if dest else (parsed_url.hostname.replace(".", "_"), '.file')
dest = self.create_artifact(fname, ext)
self.log.debug("Moving %s to %s", tmp_f_name, dest)
shutil.move(tmp_f_name, dest)
return dest
else:
filename = os.path.expanduser(filename) # expanding of '~' is required for check of existence
# check filename 'as is' and all combinations of file_search_path/filename
for dirname in [""] + self.file_search_paths:
location = os.path.join(dirname, filename)
if os.path.exists(location):
if dirname:
self.log.warning("Guessed location from search paths for %s: %s", filename, location)
return get_full_path(location)
self.log.warning("Could not find location at path: %s", filename)
return filename
def _get_http_request(url, label, method, timeout, body, keepalive):
"""
Generates HTTP request
:type method: str
:type label: str
:type url: str
:rtype: lxml.etree.Element
"""
proxy = etree.Element("HTTPSamplerProxy", guiclass="HttpTestSampleGui", testclass="HTTPSamplerProxy")
proxy.set("testname", label)
args = JMX._get_arguments_panel("HTTPsampler.Arguments")
if isinstance(body, string_types):
JMX.__add_body_from_string(args, body, proxy)
elif isinstance(body, dict):
JMX.__add_body_from_script(args, body, proxy)
elif body:
raise ValueError("Cannot handle 'body' option of type %s: %s" % (type(body), body))
parsed_url = parse.urlparse(url)
JMX.__add_hostnameport_2sampler(parsed_url, proxy, url)
path = parsed_url.path
if parsed_url.query:
path += "?" + parsed_url.query
proxy.append(JMX._string_prop("HTTPSampler.path", path))
proxy.append(JMX._string_prop("HTTPSampler.method", method))
proxy.append(JMX._bool_prop("HTTPSampler.use_keepalive", keepalive))
proxy.append(JMX._bool_prop("HTTPSampler.follow_redirects", True))
if timeout is not None:
proxy.append(JMX._string_prop("HTTPSampler.connect_timeout", timeout))
proxy.append(JMX._string_prop("HTTPSampler.response_timeout", timeout))
return proxy
def build_source_code(self):
self.log.debug("Generating Test Case test methods")
imports = self.add_imports()
self.root.append(imports)
test_class = self.gen_class_definition("TestRequests", ["unittest.TestCase"])
self.root.append(test_class)
test_class.append(self.gen_setup_method())
test_class.append(self.gen_teardown_method())
requests = self.scenario.get_requests(require_url=False)
default_address = self.scenario.get("default-address", None)
test_method = self.gen_test_method('test_requests')
self.gen_setup(test_method)
for req in requests:
if req.label:
label = req.label
elif req.url:
label = req.url
else:
raise TaurusConfigError("You must specify at least 'url' or 'label' for each requests item")
test_method.append(self.gen_statement('with apiritif.transaction(%r):' % label, indent=8))
transaction_contents = []
if req.url is not None:
parsed_url = parse.urlparse(req.url)
if default_address is not None and not parsed_url.netloc:
url = default_address + req.url
else:
url = req.url
if req.timeout is not None:
test_method.append(self.gen_impl_wait(req.timeout, indent=12))
transaction_contents.append(self.gen_statement("self.driver.get(%r)" % url, indent=12))
transaction_contents.append(self.gen_new_line(indent=0))
actions = req.config.get("actions", [])
for action_config in actions:
transaction_contents.append(self.gen_action(action_config, indent=12))
if actions:
transaction_contents.append(self.gen_new_line(indent=0))
if transaction_contents:
for line in transaction_contents:
test_method.append(line)
else:
test_method.append(self.gen_statement('pass', indent=12))
test_method.append(self.gen_new_line(indent=0))
if "assert" in req.config:
test_method.append(self.gen_statement("body = self.driver.page_source"))
for assert_config in req.config.get("assert"):
for elm in self.gen_assertion(assert_config):
test_method.append(elm)
test_method.append(self.gen_new_line(indent=0))
think_time = req.priority_option('think-time')
if think_time is not None:
test_method.append(self.gen_statement("sleep(%s)" % dehumanize_time(think_time)))
test_method.append(self.gen_new_line(indent=0))
test_class.append(test_method)
def is_url(url):
return parse.urlparse(url).scheme in ["https", "http"]
def _embed_query_in_path(self, path, query_dict):
self.log.debug("Query dict: %s", query_dict)
parts = parse.urlparse(path)
query = urlencode(query_dict)
replaced = parts._replace(query=query)
return parse.urlunparse(replaced)
def _embed_query_in_path(self, path, query_dict):
self.log.info(query_dict)
parts = parse.urlparse(path)
query = urlencode(query_dict)
replaced = parts._replace(query=query)
return parse.urlunparse(replaced)
def is_url(url):
return parse.urlparse(url).scheme in ["https", "http"]
