def run(self, pav_cfg, args):
"""Run this command."""
filter_func = None
if not args.all:
filter_func = filters.make_test_run_filter(
complete=args.complete,
failed=args.failed,
incomplete=args.incomplete,
name=args.name,
newer_than=args.newer_than,
older_than=args.older_than,
passed=args.passed,
result_error=args.result_error,
show_skipped=args.show_skipped,
sys_name=args.sys_name,
user=args.user)
end = '\n' if args.verbose else '\r'
# Clean Tests
tests_dir = pav_cfg.working_dir / 'test_runs' # type: Path
output.fprint("Removing Tests...", file=self.outfile, end=end)
rm_tests_count, msgs = clean.delete_tests(tests_dir, filter_func,
args.verbose)
if args.verbose:
for msg in msgs:
output.fprint(msg, color=output.YELLOW)
output.fprint("Removed {} test(s).".format(rm_tests_count),
file=self.outfile,
color=output.GREEN,
clear=True)
# Clean Series
series_dir = pav_cfg.working_dir / 'series' # type: Path
output.fprint("Removing Series...", file=self.outfile, end=end)
rm_series_count, msgs = clean.delete_series(series_dir, args.verbose)
if args.verbose:
for msg in msgs:
output.fprint(msg, color=output.YELLOW)
output.fprint("Removed {} series.".format(rm_series_count),
file=self.outfile,
color=output.GREEN,
clear=True)
# Clean Builds
builds_dir = pav_cfg.working_dir / 'builds' # type: Path
output.fprint("Removing Builds...", file=self.outfile, end=end)
rm_builds_count, msgs = clean.delete_builds(builds_dir, tests_dir,
args.verbose)
if args.verbose:
for msg in msgs:
output.fprint(msg, color=output.YELLOW)
output.fprint("Removed {} build(s).".format(rm_builds_count),
file=self.outfile,
color=output.GREEN,
clear=True)
return 0
def test_make_test_run_filter(self):
"""Check that the series filter options all work."""
now = dt.datetime.now()
always_match_test = TestAttributes(Path('dummy'))
always_match_test._attrs = {
'complete': True,
'created': now - dt.timedelta(minutes=5),
'name': 'mytest.always_match',
'result': TestRun.PASS,
'skipped': False,
'sys_name': 'this',
'user': '******',
}
never_match_test = TestAttributes(Path('dummy'))
never_match_test._attrs = {
'complete': False,
'created': now - dt.timedelta(minutes=1),
'name': 'yourtest.never_match',
'result': TestRun.FAIL,
'skipped': True,
'sys_name': 'that',
'user': '******',
}
# Setting any of this will be ok for the 'always' pass test,
# but never ok for the 'never' pass test.
opt_set = {
'show_skipped': 'no',
'complete': True,
'user': '******',
'sys_name': 'this',
'passed': True,
'older_than': now - dt.timedelta(minutes=2),
'name': 'mytest.*',
}
# These are the opposite. The 'always' pass test won't, and the
# 'never' pass will.
inv_opt_set = {
'incomplete': True,
'failed': True,
'result_error': True,
'newer_than': now - dt.timedelta(minutes=2),
}
for opt, val in opt_set.items():
tr_filter = filters.make_test_run_filter(**{opt: val})
self.assertTrue(tr_filter(always_match_test),
msg="Failed on opt, val ({}, {})\n{}".format(
opt, val, always_match_test.attr_dict()))
self.assertFalse(tr_filter(never_match_test),
msg="Failed on opt, val ({}, {})\n{}".format(
opt, val, never_match_test.attr_dict()))
for opt, val in inv_opt_set.items():
tr_filter = filters.make_test_run_filter(**{opt: val})
self.assertFalse(tr_filter(always_match_test),
msg="Failed on opt, val ({}, {})\n{}".format(
opt, val, always_match_test.attr_dict()))
if opt != 'result_error': # Fails on this one (expected)
self.assertTrue(tr_filter(never_match_test),
msg="Failed on opt, val ({}, {})\n{}".format(
opt, val, never_match_test.attr_dict()))
def test_make_series_filter(self):
"""Check the filter maker function."""
now = dt.datetime.now()
class DummySeriesInfo:
"""A class to assign arbitrary attributes to."""
base = {
'complete': False,
'incomplete': False,
'user': None,
'sys_name': None,
'older_than': None,
'newer_than': None,
}
always_match_series = DummySeriesInfo()
always_match_series.complete = True
always_match_series.created = now - dt.timedelta(minutes=5)
always_match_series.sys_name = 'this'
always_match_series.user = '******'
never_match_series = DummySeriesInfo()
never_match_series.complete = False
never_match_series.created = now - dt.timedelta(minutes=1)
never_match_series.sys_name = 'that'
never_match_series.user = '******'
# Setting any of this will be ok for the 'always' pass test,
# but never ok for the 'never' pass test.
opt_set = {
'complete': True,
'user': '******',
'sys_name': 'this',
'older_than': now - dt.timedelta(minutes=2),
}
# These are the opposite. The 'always' pass test won't, and the
# 'never' pass will.
inv_opt_set = {
'incomplete': True,
'newer_than': now - dt.timedelta(minutes=2),
}
for opt, val in opt_set.items():
opts = base.copy()
opts[opt] = val
series_filter = filters.make_series_filter(**opts)
self.assertTrue(series_filter(always_match_series),
msg="Failed on opt, val ({}, {})".format(opt, val))
self.assertFalse(series_filter(never_match_series),
msg="Failed on opt, val ({}, {})".format(
opt, val))
for opt, val in inv_opt_set.items():
opts = base.copy()
opts[opt] = val
series_filter = filters.make_test_run_filter(**opts)
self.assertFalse(series_filter(always_match_series),
msg="Failed on opt, val ({}, {})".format(
opt, val))
self.assertTrue(series_filter(never_match_series),
msg="Failed on opt, val ({}, {})".format(opt, val))
def _test_runs_cmd(self, pav_cfg, args):
"""
:param pav_cfg:
:param args:
:return:
"""
if args.show_fields:
for field in TestAttributes.list_attrs():
output.fprint(field,
'-',
TestAttributes.attr_doc(field),
file=self.outfile)
return 0
fields, mode = self.get_fields(
fields_arg=args.out_fields,
mode_arg=args.output_mode,
default_single_field='id',
default_fields=self.RUN_LONG_FIELDS,
avail_fields=TestAttributes.list_attrs())
filter_func = filters.make_test_run_filter(
complete=args.complete,
failed=args.failed,
incomplete=args.incomplete,
name=args.name,
newer_than=args.newer_than,
older_than=args.older_than,
passed=args.passed,
show_skipped=args.show_skipped,
sys_name=args.sys_name,
user=args.user,
)
order_func, ascending = filters.get_sort_opts(args.sort_by,
filters.TEST_SORT_FUNCS)
if args.series:
picked_runs = []
for series_id in args.series:
try:
picked_runs.extend(
TestSeries.list_series_tests(pav_cfg=pav_cfg,
sid=series_id))
except TestSeriesError as err:
output.fprint("Invalid test series '{}'.\n{}".format(
series_id, err.args[0]),
color=output.RED,
file=self.errfile)
return errno.EINVAL
runs = dir_db.select_from(
paths=picked_runs,
transform=TestAttributes,
filter_func=filter_func,
order_func=order_func,
order_asc=ascending,
limit=args.limit,
)
else:
runs = dir_db.select(
id_dir=pav_cfg.working_dir / 'test_runs',
transform=TestAttributes,
filter_func=filter_func,
order_func=order_func,
order_asc=ascending,
limit=args.limit,
)
self.write_output(
mode=mode,
rows=[run.attr_dict(include_empty=False) for run in runs],
fields=fields,
header=args.header,
vsep=args.vsep,
wrap=args.wrap,
)
def test_make_series_filter(self):
"""Check the filter maker function."""
now = time.time()
base = {
'complete': False,
'incomplete': False,
'user': None,
'sys_name': None,
'older_than': None,
'newer_than': None,
}
always_match_series = {
'complete': True,
'created': now - 5*60,
'sys_name': 'this',
'user': '******',
}
never_match_series = {
'complete': False,
'created': now - 1*60,
'sys_name': 'that',
'user': '******',
}
# Setting any of this will be ok for the 'always' pass test,
# but never ok for the 'never' pass test.
opt_set = {
'complete': True,
'user': '******',
'sys_name': 'this',
'older_than': now - 2*60,
}
# These are the opposite. The 'always' pass test won't, and the
# 'never' pass will.
inv_opt_set = {
'incomplete': True,
'newer_than': now - 2*60,
}
for opt, val in opt_set.items():
opts = base.copy()
opts[opt] = val
series_filter = filters.make_series_filter(**opts)
self.assertTrue(series_filter(always_match_series),
msg="Failed on opt, val ({}, {})"
.format(opt, val))
self.assertFalse(series_filter(never_match_series),
msg="Failed on opt, val ({}, {})"
.format(opt, val))
for opt, val in inv_opt_set.items():
opts = base.copy()
opts[opt] = val
series_filter = filters.make_test_run_filter(**opts)
self.assertFalse(series_filter(always_match_series),
msg="Failed on opt, val ({}, {})"
.format(opt, val))
self.assertTrue(series_filter(never_match_series),
msg="Failed on opt, val ({}, {})"
.format(opt, val))
def arg_filtered_tests(pav_cfg,
args: argparse.Namespace,
verbose: TextIO = None) -> List[int]:
"""Search for test runs that match based on the argument values in args,
and return a list of matching test id's.
Note: I know this violates the idea that we shouldn't be passing a
generic object around and just using random bits of an undefined interface.
BUT:
1. The interface is well defined, by `filters.add_test_filter_args`.
2. All of the used bits are *ALWAYS* used, so any errors will pop up
immediately in unit tests.
:param pav_cfg: The Pavilion config.
:param args: An argument namespace with args defined by
`filters.add_test_filter_args`, plus one additional `tests` argument
that should contain a list of test id's, series id's, or the 'last'
keyword.
:param verbose: A file like object to report test search status.
:return: A list of test id ints.
"""
limit = args.limit
filter_func = filters.make_test_run_filter(
complete=args.complete,
incomplete=args.incomplete,
passed=args.passed,
failed=args.failed,
name=args.name,
user=args.user,
sys_name=args.sys_name,
older_than=args.older_than,
newer_than=args.newer_than,
show_skipped=args.show_skipped,
)
order_func, order_asc = filters.get_sort_opts(
sort_name=args.sort_by,
choices=filters.TEST_SORT_FUNCS,
)
if args.tests:
test_paths = test_list_to_paths(pav_cfg, args.tests)
if args.disable_filter:
test_ids = dir_db.paths_to_ids(test_paths)
else:
tests = dir_db.select_from(paths=test_paths,
transform=test_run_attr_transform,
filter_func=filter_func,
order_func=order_func,
order_asc=order_asc,
limit=limit).data
test_ids = [test['id'] for test in tests]
else:
tests = dir_db.select(id_dir=pav_cfg.working_dir / 'test_runs',
transform=test_run_attr_transform,
filter_func=filter_func,
order_func=order_func,
order_asc=order_asc,
verbose=verbose,
limit=limit).data
test_ids = [test['id'] for test in tests]
return test_ids
