def run_main(subcommand,
lines,
main_args=None,
subcommand_args=None,
to_stdout=False):
in_fh, in_fn = tmp_file(lines=lines)
in_fh.close()
out_fh, out_fn = tempfile.mkstemp()
if not main_args:
main_args = []
main_args.extend([subcommand, "--input", str(in_fn)])
if not to_stdout:
main_args.extend(["--output", str(out_fn)])
if subcommand_args:
main_args.extend(subcommand_args)
with captured_output() as (stdout, stderr):
main(args=main_args)
fh = open(out_fn, "r")
out_lines = [line.rstrip("\r\n") for line in fh]
fh.close()
stdout = stdout.getvalue().rstrip('\r\n').split("\n")
stderr = stderr.getvalue().rstrip('\r\n').split("\n")
os.remove(in_fn)
os.remove(out_fn)
return (out_lines, stdout, stderr)
def __sort(self, lines, extra_args, test_func, to_stdout=False):
in_fh, in_fn = tmp_file(lines=lines)
in_fh.close()
out_fh, out_fn = tempfile.mkstemp()
main_args = ["validate", "--input", str(in_fn)]
if not to_stdout:
main_args.extend(["--output", str(out_fn)])
main_args.extend(extra_args)
with captured_output() as (stdout, stderr):
main(args=main_args)
fh = open(out_fn, "r")
out_lines = [line.rstrip("\r\n") for line in fh]
fh.close()
stdout = stdout.getvalue().rstrip('\r\n').split("\n")
stderr = stderr.getvalue().rstrip('\r\n').split("\n")
test_func(out_lines=out_lines, stdout=stdout, stderr=stderr)
os.remove(in_fn)
os.remove(out_fn)
def test_empty_file(self):
fd, path = tempfile.mkstemp()
# No logging to stderr/stdout
with captured_output() as (stdout, stderr):
writer = MafWriter.from_path(
path=path,
header=MafHeader(),
validation_stringency=ValidationStringency.Silent,
)
writer.close()
self.assertEqual(read_lines(path), [])
self.assertEqual(str(writer.header()), "")
stdout = stdout.getvalue().rstrip('\r\n').split("\n")
stderr = stderr.getvalue().rstrip('\r\n').split("\n")
self.assertListEqual(stdout, [''])
self.assertListEqual(stderr, [''])
# Logging to stderr/stdout
with captured_output() as (stdout, stderr):
writer = MafWriter.from_path(
path=path,
header=MafHeader(),
validation_stringency=ValidationStringency.Lenient,
)
writer.close()
self.assertEqual(read_lines(path), [])
self.assertEqual(str(writer.header()), "")
stdout = stdout.getvalue().rstrip('\r\n').split("\n")
stderr = stderr.getvalue().rstrip('\r\n').split("\n")
self.assertListEqual(stdout, [''])
self.assertListEqualAndIn(
['HEADER_MISSING_VERSION', 'HEADER_MISSING_ANNOTATION_SPEC'],
stderr)
# Exceptions
with captured_output():
with self.assertRaises(MafFormatException) as context:
writer = MafWriter.from_path(
path=path,
header=MafHeader(),
validation_stringency=ValidationStringency.Strict,
)
self.assertEqual(context.exception.tpe,
MafValidationErrorType.HEADER_MISSING_VERSION)
def test_max_errors(self):
# Silly user
subcommand_args = ["--max-errors", "0"]
with captured_output() as (stdout, stderr):
with self.assertRaises(SystemExit) as context:
self.__validate__(lines=[], subcommand_args=subcommand_args)
# Verbose Mode: there should be an error about the version missing from
# the header! No error about the missing column
lines=[
"\t".join(["c1", "c2", "c3"]),
"\t".join(["v1", "v2", "v3"]),
"\t".join(["v1"]),
"\t".join(["v1", "v2"])
]
subcommand_args = ["--max-errors", "1"]
out_lines, stdout, stderr = self.__validate__(
lines=lines,
subcommand_args=subcommand_args)
self.assertListEqual(stdout, [''])
self.assertEqual(len(stderr), 2)
self.assertTrue("Maximum number of errors encountered" in stderr[1])
# Verbose Mode: there should be an error in the header and records
subcommand_args = ["--max-errors", "3", "--mode", "Verbose"]
out_lines, stdout, stderr = self.__validate__(
lines=lines,
subcommand_args=subcommand_args)
self.assertListEqualAndIn([
"No version line found in the header",
"No annotation.spec line found in the header",
"On line number 3: Found '1' columns but expected '3'"],
out_lines)
self.assertListEqual(stdout, [''])
self.assertTrue("Maximum number of errors encountered" in stderr[1])
# Summary Mode: there should be an error in the header and records
subcommand_args = ["--max-errors", "3", "--mode", "Summary"]
out_lines, stdout, stderr = self.__validate__(
lines=lines,
subcommand_args=subcommand_args)
self.assertListEqualAndIn(
['Error Type\tCount\tDescription',
'HEADER_MISSING_ANNOTATION_SPEC\t1\tThe header has no annotation spec',
'HEADER_MISSING_VERSION\t1\tThe header has no version',
'RECORD_MISMATCH_NUMBER_OF_COLUMNS\t1\tThe record has an '
'unexpected number of columns'],
out_lines)
self.assertListEqual(stdout, [''])
self.assertTrue("Maximum number of errors encountered" in stderr[1])
def test_record_validation_error(self):
scheme = TestMafWriter.TestScheme()
fd, path = tempfile.mkstemp()
# Create the header
header_lines = (MafHeader.scheme_header_lines(scheme) +
["#key1 value1", "#key2 value2"] +
["str1\tNone\tstr2"])
header = MafHeader.from_lines(
lines=header_lines,
validation_stringency=ValidationStringency.Silent)
# Create the record
values = ["string2", "error", "string1"]
record_line = MafRecord.ColumnSeparator.join(values)
record = MafRecord.from_line(
line=record_line,
scheme=scheme,
line_number=1,
validation_stringency=ValidationStringency.Silent,
)
# Write the header, and the record twice
with captured_output() as (stdout, stderr):
writer = MafWriter.from_path(
header=header,
validation_stringency=ValidationStringency.Lenient,
path=path,
)
writer += record
writer.write(record)
writer.close()
stdout = stdout.getvalue().rstrip('\r\n').split("\n")
stderr = stderr.getvalue().rstrip('\r\n').split("\n")
self.assertListEqual(stdout, [''])
# The errors that should be written stderr
errors = [
"HEADER_UNSUPPORTED_VERSION",
"HEADER_UNSUPPORTED_ANNOTATION_SPEC",
"RECORD_COLUMN_WITH_NO_VALUE",
"RECORD_COLUMN_WITH_NO_VALUE",
]
self.assertListEqualAndIn(errors, stderr)
# The second column should be None
err_record_line = record_line.replace("error", "None")
self.assertListEqual(read_lines(path),
header_lines + [err_record_line, err_record_line])
def test_gz_support(self):
fd, path = tempfile.mkstemp(suffix=".gz")
lines = [TestMafWriter.__version_line,
TestMafWriter.__annotation_line,
"#key1 value1",
"#key2 value2",
TestMafWriter.__keys_line
]
with captured_output() as (stdout, stderr):
header = MafHeader.from_lines(lines=lines)
writer = MafWriter.from_path(header=header, path=path)
writer.close()
self.assertListEqual(read_lines(path), lines)
self.assertEqual(str(writer.header()) + "\n" +
TestMafWriter.__keys_line,
"\n".join(lines))
stdout = stdout.getvalue().rstrip('\r\n').split("\n")
stderr = stderr.getvalue().rstrip('\r\n').split("\n")
self.assertListEqual(stdout, [''])
self.assertListEqual(stderr, [''])
os.remove(path)
def test_no_inputs(self):
with captured_output() as (_, stderr):
with self.assertRaises(SystemExit) as context:
main(args=['sort'])