def test_multitest_drivers_in_testplan(runpath):
"""TODO."""
for idx, opts in enumerate((dict(name="MyPlan",
runpath=runpath), dict(name="MyPlan"))):
plan = TestplanMock(**opts)
server = TCPServer(name="server")
client = TCPClient(
name="client",
host=context(server.cfg.name, "{{host}}"),
port=context(server.cfg.name, "{{port}}"),
)
mtest = MultiTest(
name="Mtest",
suites=[MySuite()],
environment=[server, client],
initial_context={"test_key": "test_value"},
)
plan.add(mtest)
assert server.status.tag == ResourceStatus.NONE
assert client.status.tag == ResourceStatus.NONE
plan.run()
res = plan.result
assert res.run is True
assert res.report.passed
if idx == 0:
assert plan.runpath == runpath
assert mtest.runpath == os.path.join(plan.runpath,
slugify(mtest.uid()))
assert server.runpath == os.path.join(mtest.runpath, server.uid())
assert client.runpath == os.path.join(mtest.runpath, client.uid())
assert server.status.tag == ResourceStatus.STOPPED
assert client.status.tag == ResourceStatus.STOPPED
def export(self, source):
"""Create multiple XML files in the given directory for each top level test group report."""
xml_dir = self.cfg.xml_dir
if os.path.exists(xml_dir):
shutil.rmtree(xml_dir)
os.makedirs(xml_dir)
files = set(os.listdir(xml_dir))
for child_report in source:
filename = '{}.xml'.format(slugify(child_report.name))
filename = unique_name(filename, files)
files.add(filename)
file_path = os.path.join(self.cfg.xml_dir, filename)
# If a report has XML string attribute it was mostly generated via parsing
# a JUnit compatible XML file already, meaning we don't need to re-generate
# the XML contents, but can directly write the contents to a file instead.
if hasattr(child_report, 'xml_string'):
with open(file_path, 'w') as xml_target:
xml_target.write(child_report.xml_string)
else:
renderer = self.renderer_map.get(child_report.category, BaseRenderer)()
element = etree.ElementTree(renderer.render(child_report))
element.write(
file_path,
pretty_print=True,
xml_declaration=True,
encoding='UTF-8'
)
TESTPLAN_LOGGER.exporter_info(
'%s XML files created at: %s', len(source), xml_dir)
def __init__(
self,
name,
msgclass,
codec,
host,
port,
sender,
target,
version="FIX.4.2",
sendersub=None,
interface=None,
connect_at_start=True,
logon_at_start=True,
custom_logon_tags=None,
receive_timeout=30,
logon_timeout=10,
logoff_timeout=3,
**options
):
options.update(self.filter_locals(locals()))
options.setdefault("file_logger", "{}.log".format(slugify(name)))
super(FixClient, self).__init__(**options)
self._host = None
self._port = None
self._client = None
def _define_remote_dirs(self):
"""Define mandatory directories in remote host."""
testplan_path_dirs = ['', 'var', 'tmp', getpass.getuser(), 'testplan']
self._remote_testplan_path = '/'.join(
testplan_path_dirs + ['remote_workspaces',
slugify(self.cfg.parent.parent.name)])
self._remote_testplan_runpath = '/'.join(
[self._remote_testplan_path, 'runpath', str(self.cfg.index)])
def __init__(self, **options):
super(HTTPClient, self).__init__(**options)
self._host = None
self._port = None
self.timeout = None
self.interval = None
self.responses = None
self._logname = '{0}.log'.format(slugify(self.cfg.name))
def test_comparison(self, env, result):
if self._boobytrap_path.exists():
self._boobytrap_path.unlink()
print("Killing worker {}".format(os.getpid()))
os.kill(os.getpid(), 9)
result.equal(1, 1, "equality description")
result.log(env.parent.runpath)
assert isinstance(env.parent.cfg, MultiTestConfig)
assert os.path.exists(env.parent.runpath) is True
assert env.parent.runpath.endswith(slugify(env.parent.cfg.name))
def _define_remote_dirs(self):
"""Define mandatory directories in remote host."""
testplan_path_dirs = ["", "var", "tmp", getpass.getuser(), "testplan"]
self._remote_testplan_path = "/".join(
testplan_path_dirs +
["remote_worker_area",
slugify(self.cfg.parent.parent.name)])
self._remote_testplan_runpath = "/".join(
[self._remote_testplan_path, "runpath",
str(self.cfg.remote_host)])
def test_comparison(self, env, result):
parent = psutil.Process(self._parent_pid)
if len(parent.children(recursive=False)) == self._size:
print("Killing worker {}".format(os.getpid()))
os.kill(os.getpid(), 9)
result.equal(1, 1, "equality description")
result.log(env.parent.runpath)
assert isinstance(env.parent.cfg, MultiTestConfig)
assert os.path.exists(env.parent.runpath) is True
assert env.parent.runpath.endswith(slugify(env.parent.cfg.name))
def get_proc_env(self):
self._json_ouput = os.path.join(self.runpath, 'output.json')
self.logger.debug('Json output: {}'.format(self._json_ouput))
env = {'JSON_REPORT': self._json_ouput}
env.update(
{key.upper(): val
for key, val in self.cfg.proc_env.items()})
for driver in self.resources:
driver_name = driver.uid()
for attr in dir(driver):
value = getattr(driver, attr)
if attr.startswith('_') or callable(value):
continue
env['DRIVER_{}_ATTR_{}'.format(
slugify(driver_name).replace('-', '_'),
slugify(attr).replace('-', '_')).upper()] = str(value)
return env
def read_test_data(self):
"""
Parse `report.xml` generated by Cppunit test and return the root node.
XML report should be compatible with xUnit format.
:return: Root node of parsed raw test data
:rtype: ``xml.etree.Element``
"""
if self.cfg.file_output_flag:
with self.result.report.logged_exceptions(), open(
self.report_path) as report_file:
return objectify.fromstring(
self.cppunit_to_junit(report_file.read(),
slugify(self.cfg.name)))
else:
with open(self.stdout) as stdout:
return objectify.fromstring(
self.cppunit_to_junit(stdout.read(),
slugify(self.cfg.name)))
def get_proc_env(self):
self._json_ouput = os.path.join(self.runpath, "output.json")
self.logger.debug("Json output: {}".format(self._json_ouput))
env = {"JSON_REPORT": self._json_ouput}
env.update(
{key.upper(): val
for key, val in self.cfg.proc_env.items()})
for driver in self.resources:
driver_name = driver.uid()
for attr in dir(driver):
value = getattr(driver, attr)
if attr.startswith("_") or callable(value):
continue
env["DRIVER_{}_ATTR_{}".format(
strings.slugify(driver_name).replace("-", "_"),
strings.slugify(attr).replace("-", "_"),
).upper()] = str(value)
return env
def __init__(self, **options):
super(HTTPServer, self).__init__(**options)
self._host = None
self._port = None
self.request_handler = None
self.handler_attributes = None
self.timeout = None
self.requests = None
self.responses = None
self._server_thread = None
self._logname = '{0}.log'.format(slugify(self.cfg.name))
def generate_runpath(self):
"""
Returns runpath directory based on parent object and configuration.
"""
# local config has highest precedence
runpath = self.cfg.get_local("runpath")
if runpath:
return runpath(self) if callable(runpath) else runpath
# else get container's runpath and append uid
elif self.parent and self.parent.runpath:
return os.path.join(self.parent.runpath, slugify(self.uid()))
else:
return default_runpath(self)
def _define_remote_dirs(self):
"""Define mandatory directories in remote host."""
runpath = os.path.join(self.parent.runpath)
runpath_parts = runpath.split(os.sep)
# We are not using os.path.join directly in case we are running
# remote pool from Windows -> Linux hosts
self._remote_testplan_path = "/".join(
runpath_parts +
["remote_testplan_lib",
slugify(self.cfg.parent.parent.name)])
self._remote_testplan_runpath = "/".join(
runpath_parts +
["remote_testplan_runpath",
str(self.cfg.remote_host)])
def export(self, source: TestReport) -> str:
"""
Creates multiple XML files in the given directory for MultiTest.
:param source:
:return:
"""
xml_dir = pathlib.Path(self.cfg.xml_dir).resolve()
if xml_dir.exists():
shutil.rmtree(xml_dir)
xml_dir.mkdir(parents=True, exist_ok=True)
files = set(os.listdir(xml_dir))
for child_report in source:
filename = "{}.xml".format(slugify(child_report.name))
filename = unique_name(filename, files)
files.add(filename)
file_path = xml_dir / filename
# TODO: "mostly" - is this just confidence or proven?
# If a report has XML string attribute it was mostly
# generated via parsing a JUnit compatible XML file
# already, meaning we don't need to re-generate the XML
# contents, but can directly write the contents to a file
# instead.
if hasattr(child_report, "xml_string"):
with open(file_path, "w") as xml_target:
xml_target.write(child_report.xml_string)
else:
renderer = self.renderer_map.get(child_report.category,
BaseRenderer)()
element = etree.ElementTree(renderer.render(child_report))
element.write(
str(file_path),
pretty_print=True,
xml_declaration=True,
encoding="utf-8",
)
self.logger.exporter_info("%s XML files created at %s", len(source),
xml_dir)
return str(xml_dir)
def __init__(self,
name,
host,
port=None,
protocol="http",
timeout=5,
interval=0.01,
**options):
options.update(self.filter_locals(locals()))
options.setdefault("file_logger", "{}.log".format(slugify(name)))
super(HTTPClient, self).__init__(**options)
self._host = None
self._port = None
self.protocol = None
self.timeout = None
self.interval = None
self.responses = None
self.request_threads = []
def __init__(self,
name,
host,
port=None,
protocol='http',
timeout=5,
interval=0.01,
**options):
options.update(self.filter_locals(locals()))
super(HTTPClient, self).__init__(**options)
self._host = None
self._port = None
self.protocol = None
self.timeout = None
self.interval = None
self.responses = None
self.request_threads = []
self._logname = '{0}.log'.format(slugify(self.cfg.name))
def generate_path_for_tags(config, tag_dict, filter_type):
"""
Generate the PDF filename using the given filter and tag context.
Will trim the filename and append a uuid suffix if it ends up
being longer than `MAX_FILENAME_LENGTH`.
TOOD: support custom filename generation & move logic to the exporter.
>>> generate_pdf_path(
... filter_type='all',
... tag_arg_dict={
... 'simple': {'foo', 'bar'},
... 'hello': {'world', 'mars'}
... }
... )
<directory>/report-tags-all-foo__bar__hello-world-mars.pdf
"""
def add_count_suffix(directory, path, count=0):
"""Add a number suffix to file name if files with same names exist."""
target_path = '{}_{}'.format(path, count) if count else path
full_path = os.path.join(config.report_dir, target_path + '.pdf')
if os.path.exists(full_path):
return add_count_suffix(directory, path, count + 1)
return full_path
tag_label = tagging.tag_label(tag_dict).replace(' ', '__').replace(
'=', '-').replace(',', '-')
path_template = 'report-tags-{filter_type}-{label}'
path_kwargs = dict(
filter_type=filter_type,
label=slugify(tag_label),
)
if config.timestamp:
path_template += '-{timestamp}'
path_kwargs['timestamp'] = config.timestamp
path = path_template.format(**path_kwargs)
if len(path) >= MAX_FILENAME_LENGTH:
path = '{}-{}'.format(path[:MAX_FILENAME_LENGTH], uuid.uuid4())
return add_count_suffix(config.report_dir, path)
def export(self, source):
"""
Create multiple XML files in the given directory for each top
level test group report.
"""
xml_dir = self.cfg.xml_dir
if os.path.exists(xml_dir):
shutil.rmtree(xml_dir)
os.makedirs(xml_dir)
files = set(os.listdir(xml_dir))
for child_report in source:
filename = "{}.xml".format(slugify(child_report.name))
filename = unique_name(filename, files)
files.add(filename)
file_path = os.path.join(xml_dir, filename)
# If a report has XML string attribute it was mostly
# generated via parsing a JUnit compatible XML file
# already, meaning we don't need to re-generate the XML
# contents, but can directly write the contents to a file
# instead.
if hasattr(child_report, "xml_string"):
with open(file_path, "w") as xml_target:
xml_target.write(child_report.xml_string)
else:
renderer = self.renderer_map.get(child_report.category,
BaseRenderer)()
element = etree.ElementTree(renderer.render(child_report))
element.write(
file_path,
pretty_print=True,
xml_declaration=True,
encoding="utf-8",
)
xml_dir = os.path.abspath(xml_dir)
self.logger.exporter_info("%s XML files created at %s", len(source),
xml_dir)
return xml_dir
def __init__(self,
name,
msgclass,
codec,
host="localhost",
port=0,
version="FIX.4.2",
**options):
options.update(self.filter_locals(locals()))
options.setdefault("file_logger", "{}.log".format(slugify(name)))
if not hasattr(select, "poll"):
raise RuntimeError(
"select.poll() is required for FixServer but is not available "
"on the current platform ({})".format(platform.system()))
super(FixServer, self).__init__(**options)
self._host = None
self._port = None
self._server = None
def __init__(self,
name,
msgclass,
codec,
host='localhost',
port=0,
version='FIX.4.2',
**options):
options.update(self.filter_locals(locals()))
if not hasattr(select, 'poll'):
raise RuntimeError(
'select.poll() is required for FixServer but is not available '
'on the current platform ({})'.format(platform.system()))
super(FixServer, self).__init__(**options)
self._host = None
self._port = None
self._server = None
self._logname = '{0}.log'.format(slugify(self.cfg.name))
def __init__(self,
name,
host='localhost',
port=0,
request_handler=HTTPRequestHandler,
handler_attributes=None,
timeout=5,
interval=0.01,
**options):
options.update(self.filter_locals(locals()))
super(HTTPServer, self).__init__(**options)
self._host = None
self._port = None
self.request_handler = None
self.handler_attributes = None
self.timeout = None
self.interval = None
self.requests = None
self.responses = None
self._server_thread = None
self._logname = '{0}.log'.format(slugify(self.cfg.name))
def __init__(self,
name,
host="localhost",
port=0,
request_handler=HTTPRequestHandler,
handler_attributes=None,
timeout=5,
interval=0.01,
**options):
options.update(self.filter_locals(locals()))
options.setdefault("file_logger", "{}.log".format(slugify(name)))
super(HTTPServer, self).__init__(**options)
self._host = None
self._port = None
self.request_handler = None
self.handler_attributes = None
self.timeout = None
self.interval = None
self.requests = None
self.responses = None
self._server_thread = None
def export(self, source):
xml_dir = self.cfg.xml_dir
if os.path.exists(xml_dir):
shutil.rmtree(xml_dir)
os.makedirs(xml_dir)
files = set(os.listdir(xml_dir))
for child_report in source:
renderer = self.renderer_map[child_report.category]()
element = etree.ElementTree(renderer.render(child_report))
filename = '{}.xml'.format(slugify(child_report.name))
filename = unique_name(filename, files)
files.add(filename)
file_path = os.path.join(self.cfg.xml_dir, filename)
element.write(file_path, pretty_print=True)
TESTPLAN_LOGGER.exporter_info(
'%s XML files created at: %s', len(source), xml_dir)
def __init__(self, **options):
super(FixClient, self).__init__(**options)
self._host = None
self._port = None
self._client = None
self._logname = '{0}.log'.format(slugify(self.cfg.name))
def test_comparison(self, env, result):
result.equal(1, 1, "equality description")
assert isinstance(env.parent.cfg, MultiTestConfig)
assert os.path.exists(env.parent.runpath)
assert env.parent.runpath.endswith(slugify(env.parent.cfg.name))
