def test_snakefile_staggered_parsing(self):
snakefile = Snakefile(StringIO(self.text))
token_buffer = list()
next(snakefile)
for _ in range(3):
token_buffer.append(next(snakefile))
for token in reversed(token_buffer):
snakefile.denext(token)
result_sequence = list()
for _ in range(3):
result_sequence.append(next(snakefile).string)
expected_sequence = ["a", ":", "\n"]
assert expected_sequence == result_sequence
def test_simple_rule_one_input(self):
stream = StringIO("rule a:\n" f'{TAB * 1}input: "foo.txt"')
smk = Snakefile(stream)
formatter = Formatter(smk)
actual = formatter.get_formatted()
expected = "rule a:\n" f"{TAB * 1}input:\n" f'{TAB * 2}"foo.txt",\n'
assert actual == expected
def test_implicitly_unrecognised_keyword(self):
"""
The keyword lives in the 'base' space, so could also be interpreted as Python
code.
In that case black will complain of invalid python and not format it.
"""
with pytest.raises(InvalidPython):
stream = StringIO(f"role a: \n" f'{TAB * 1}input: "b"')
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_param_collating(self):
"The keyword gets collated to the previous parameter value"
with pytest.raises(InvalidParameterSyntax, match="benchmark"):
stream = StringIO(
"rule a: \n"
"\tcontainer: \n"
'\t\t"envs/sing.img"\n'
'\t\t\tbenchmark: "bench.txt"'
)
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_snakefile_sequential_parsing(self):
istream = StringIO(self.text)
expected_sequence = istream.read().split()
istream.seek(0)
snakefile = Snakefile(istream)
for expected_word in expected_sequence:
try:
parsed_word = next(snakefile).string
assert expected_word == parsed_word
except Exception:
break
def test_keyword_under_indentation(self):
"The keyword gets interpreted as python code"
with pytest.raises(InvalidPython, match="benchmark"):
stream = StringIO(
"rule a: \n"
"\tcontainer: \n"
'\t\t"envs/sing.img"\n'
'benchmark: "bench.txt"'
'\toutput: "b"'
)
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_keyword_indented_at_parameter_level(self):
with pytest.raises(InvalidParameterSyntax, match="output"):
stream = StringIO(
(
"rule a: \n"
"\tinput: \n"
'\t\t"f1", \n'
"\t\toutput: \n"
'\t\t\t"f2"'
)
)
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_lambda_function_with_multiple_args(self):
stream = StringIO(
f"rule a:\n"
f'{TAB * 1}input: "foo.txt" \n'
f"{TAB * 1}resources:"
f"{TAB * 2}mem_mb = lambda wildcards, attempt: attempt * 1000")
smk = Snakefile(stream)
formatter = Formatter(smk)
actual = formatter.get_formatted()
expected = (
f"rule a:\n"
f"{TAB * 1}input:\n"
f'{TAB * 2}"foo.txt",\n'
f"{TAB * 1}resources:\n"
f"{TAB * 2}mem_mb=lambda wildcards, attempt: attempt * 1000,\n")
assert actual == expected
def test_expand_as_param(self):
stream = StringIO("rule a:\n"
f"{TAB * 1}input: \n"
f"{TAB * 2}"
'expand("{f}/{p}", f = [1, 2], p = ["1", "2"])\n'
f'{TAB * 1}output:"foo.txt","bar.txt"\n')
smk = Snakefile(stream)
formatter = Formatter(smk)
actual = formatter.get_formatted()
expected = ("rule a:\n"
f"{TAB * 1}input:\n"
f"{TAB * 2}"
'expand("{f}/{p}", f=[1, 2], p=["1", "2"]),\n'
f"{TAB * 1}output:\n"
f'{TAB * 2}"foo.txt",\n'
f'{TAB * 2}"bar.txt",\n')
assert actual == expected
def test_invalid_name_for_keyword(self):
with pytest.raises(NamedKeywordError, match="Invalid name.*checkpoint"):
stream = StringIO("checkpoint (): \n" '\tinput: "a"')
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_key_value_invalid_key_fails(self):
with pytest.raises(InvalidParameterSyntax, match="Invalid key"):
stream = StringIO("rule a:" '\n\tinput: \n\t\t2 = "file.txt"')
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_empty_keyword_3(self):
with pytest.raises(NoParametersError, match="message"):
stream = StringIO("rule a:" "\n\tthreads: 3" "\n\tmessage:")
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_empty_keyword_SMK_NOBREAK(self):
with pytest.raises(EmptyContextError, match="rule"):
stream = StringIO("rule a:")
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_duplicate_rule_fails_SMK_NOBREAK(self):
with pytest.raises(DuplicateKeyWordError, match="rule a"):
stream = StringIO("rule a:\n" '\tinput: "a"\n' "rule a:\n" '\tinput:"b"')
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_single_parameter_keyword_disallows_multiple_parameters(self):
with pytest.raises(TooManyParameters, match="benchmark"):
stream = StringIO("rule a:" '\n\tbenchmark: "f1.txt", "f2.txt"')
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_explicitly_unrecognised_keyword(self):
with pytest.raises(SyntaxError, match="Unrecognised keyword"):
stream = StringIO("rule a:" "\n\talien_keyword: 3")
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_single_parameter_keyword_disallows_kwarg(self):
with pytest.raises(InvalidParameter, match="container .* positional"):
stream = StringIO("rule a: \n" '\tcontainer: a = "envs/sing.img"')
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_keyword_cannot_be_named(self):
with pytest.raises(SyntaxError, match="Colon.*expected"):
stream = StringIO('workdir a: "/to/dir"')
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_no_newline_in_keyword_context_SMK_NOBREAK(self):
with pytest.raises(SyntaxError, match="Newline expected"):
stream = StringIO('rule a: input: "input_file"')
snakefile = Snakefile(stream)
Formatter(snakefile)
def test_nocolon(self):
with pytest.raises(SyntaxError, match="Colon.*expected"):
stream = StringIO("rule a")
snakefile = Snakefile(stream)
Formatter(snakefile)