209 lines
7.4 KiB
Python
209 lines
7.4 KiB
Python
"""Regression tests for _rewrite_compound_background.
|
|
|
|
Context: bash parses ``A && B &`` as ``(A && B) &`` — it forks a subshell
|
|
for the compound and backgrounds the subshell. Inside the subshell, B
|
|
runs foreground, so the subshell waits for B. When B never exits on its
|
|
own (HTTP servers, ``yes > /dev/null``, etc.), the subshell is stuck in
|
|
``wait4`` forever and leaks as an orphan process. Pre-fix, we saw this
|
|
pattern leak processes across the fleet (vela, sal, combiagent).
|
|
|
|
The rewriter fixes this by wrapping the tail in a brace group —
|
|
``A && { B & }`` — so B runs as a simple backgrounded command inside
|
|
the current shell. No subshell fork, no wait.
|
|
"""
|
|
|
|
import shutil
|
|
import subprocess
|
|
|
|
import pytest
|
|
|
|
from tools.terminal_tool import _rewrite_compound_background as rewrite
|
|
|
|
|
|
class TestRewrites:
|
|
"""Commands that trigger the subshell-wait bug MUST be rewritten."""
|
|
|
|
def test_simple_and_background(self):
|
|
assert rewrite("A && B &") == "A && { B & }"
|
|
|
|
def test_or_background(self):
|
|
assert rewrite("A || B &") == "A || { B & }"
|
|
|
|
|
|
def test_multiple_rewrites_in_one_script(self):
|
|
cmd = "A && B &\nfalse || C &"
|
|
assert rewrite(cmd) == "A && { B & }\nfalse || { C & }"
|
|
|
|
|
|
class TestPreserved:
|
|
"""Commands that DON'T have the bug MUST pass through unchanged."""
|
|
|
|
def test_simple_background(self):
|
|
# No compound — just background a single command. Works fine as-is.
|
|
assert rewrite("sleep 5 &") == "sleep 5 &"
|
|
|
|
def test_plain_server_background(self):
|
|
assert rewrite("python3 -m http.server 0 &") == "python3 -m http.server 0 &"
|
|
|
|
|
|
def test_whitespace_only(self):
|
|
assert rewrite(" \n\t") == " \n\t"
|
|
|
|
|
|
class TestRedirectsNotConfused:
|
|
"""``&>``, ``2>&1``, ``>&2`` must not be mistaken for background ``&``."""
|
|
|
|
def test_amp_gt_redirect_alone(self):
|
|
assert rewrite("echo hi &>/dev/null") == "echo hi &>/dev/null"
|
|
|
|
|
|
def test_gt_amp_inside_compound(self):
|
|
cmd = "A && B 2>&1 &"
|
|
assert rewrite(cmd) == "A && { B 2>&1 & }"
|
|
|
|
|
|
class TestQuotingAndParens:
|
|
"""Shell metacharacters inside quotes/parens must not be parsed as operators."""
|
|
|
|
def test_and_and_inside_single_quotes(self):
|
|
cmd = "echo 'A && B &'"
|
|
assert rewrite(cmd) == "echo 'A && B &'"
|
|
|
|
|
|
def test_backslash_escaped_ampersand(self):
|
|
# Escaped & is not a background operator.
|
|
cmd = r"echo A \&\& B"
|
|
assert rewrite(cmd) == cmd
|
|
|
|
def test_comment_line_not_rewritten(self):
|
|
cmd = "# A && B &\nC"
|
|
assert rewrite(cmd) == "# A && B &\nC"
|
|
|
|
|
|
class TestIdempotence:
|
|
"""Running the rewriter twice should be a no-op on its own output."""
|
|
|
|
def test_already_rewritten(self):
|
|
once = rewrite("A && B &")
|
|
twice = rewrite(once)
|
|
assert once == twice
|
|
assert twice == "A && { B & }"
|
|
|
|
def test_multiline_idempotent(self):
|
|
once = rewrite("cd /tmp && server &\nsleep 1")
|
|
assert rewrite(once) == once
|
|
|
|
|
|
class TestEdgeCases:
|
|
def test_only_chain_op_no_second_command(self):
|
|
# Malformed input: bash would error, we shouldn't crash or rewrite.
|
|
cmd = "A && &"
|
|
# Don't assert a specific output; just don't raise.
|
|
rewrite(cmd)
|
|
|
|
|
|
def test_tabs_between_tokens(self):
|
|
assert rewrite("A\t&&\tB\t&") == "A\t&&\t{ B\t& }"
|
|
|
|
|
|
class TestTrailingStatementSeparator:
|
|
"""A statement after the backgrounded compound on the SAME line.
|
|
|
|
In ``A && B & C`` the trailing ``&`` is both the background operator and
|
|
the separator between the compound and ``C``. The rewrite consumes that
|
|
``&`` into the brace group; without restoring a separator the result is
|
|
``A && { B & } C`` — a bash syntax error (a brace group must be terminated
|
|
by ``;``, ``&``, ``|``, a newline, or ``)``/``}`` before the next command).
|
|
That mangles a valid command into one that fails entirely.
|
|
"""
|
|
|
|
def test_trailing_command_gets_separator(self):
|
|
assert rewrite("echo hi && sleep 5 & echo done") == (
|
|
"echo hi && { sleep 5 & } ; echo done"
|
|
)
|
|
|
|
def test_trailing_chain_gets_separator(self):
|
|
assert rewrite("a && b & c && d") == "a && { b & } ; c && d"
|
|
|
|
def test_redirect_then_trailing_command(self):
|
|
assert rewrite("echo hi && sleep 5 &>/dev/null & echo done") == (
|
|
"echo hi && { sleep 5 &>/dev/null & } ; echo done"
|
|
)
|
|
|
|
def test_existing_semicolon_separator_untouched(self):
|
|
# An explicit `;` already separates the group; don't add a second one.
|
|
assert rewrite("a && b &; c") == "a && { b & }; c"
|
|
|
|
def test_newline_separator_untouched(self):
|
|
# A newline already terminates the brace group — no `;` needed.
|
|
assert rewrite("a && b &\necho next") == "a && { b & }\necho next"
|
|
|
|
def test_pipe_after_group_untouched(self):
|
|
# `{ ...; } | cmd` is valid; the pipe is its own terminator.
|
|
assert rewrite("a && b & | cat") == "a && { b & } | cat"
|
|
|
|
def test_redirect_prefix_on_trailing_command_gets_separator(self):
|
|
# `&>` after the group is a redirect for the NEXT command, not a
|
|
# terminator: `{ b & } &>/dev/null c` is a syntax error.
|
|
assert rewrite("a && b & &>/dev/null c") == "a && { b & } ; &>/dev/null c"
|
|
|
|
def test_case_arm_terminator_untouched(self):
|
|
# `;;` already terminates the arm; adding `;` would leave an empty
|
|
# command between `;` and `;;`, which bash rejects.
|
|
assert rewrite("case $x in p) b && c & ;; esac") == "case $x in p) b && { c & } ;; esac"
|
|
|
|
def test_separator_is_idempotent(self):
|
|
once = rewrite("echo hi && sleep 5 & echo done")
|
|
assert rewrite(once) == once
|
|
|
|
def test_second_background_then_trailing(self):
|
|
assert rewrite("echo a && sleep 5 & echo b & echo c") == (
|
|
"echo a && { sleep 5 & } ; echo b & echo c"
|
|
)
|
|
|
|
|
|
@pytest.mark.skipif(shutil.which("bash") is None, reason="bash not available")
|
|
class TestRewriteIsValidBash:
|
|
"""The rewrite must always produce syntactically valid bash.
|
|
|
|
This is the crux of the trailing-statement bug: a mangled command fails
|
|
with a confusing syntax error and neither half runs. ``bash -n`` parses
|
|
without executing, so it catches the corruption directly.
|
|
"""
|
|
|
|
@pytest.mark.parametrize(
|
|
"command",
|
|
[
|
|
"echo hi && sleep 5 & echo done",
|
|
"a && b & c && d",
|
|
"echo hi && sleep 5 &>/dev/null & echo done",
|
|
"echo a && sleep 5 & echo b & echo c",
|
|
"A && B &",
|
|
"A && B &; C",
|
|
"A && B &\nC",
|
|
"cd /tmp && python3 -m http.server 0 &>/dev/null & curl localhost",
|
|
"a && b & &>/dev/null c",
|
|
"case $x in p) b && c & ;; esac",
|
|
"A && B & echo x\nC && D & echo y && E & echo z",
|
|
],
|
|
)
|
|
def test_rewrite_parses(self, command):
|
|
rewritten = rewrite(command)
|
|
result = subprocess.run(
|
|
["bash", "-n", "-c", rewritten],
|
|
capture_output=True,
|
|
text=True,
|
|
)
|
|
assert result.returncode == 0, (
|
|
f"rewrite produced invalid bash: {rewritten!r}\n{result.stderr}"
|
|
)
|
|
|
|
def test_trailing_statement_actually_runs(self):
|
|
# End-to-end: the command after the backgrounded compound must run.
|
|
rewritten = rewrite("echo first && true & echo SECOND_RAN")
|
|
result = subprocess.run(
|
|
["bash", "-c", rewritten], capture_output=True, text=True
|
|
)
|
|
assert result.returncode == 0
|
|
assert "SECOND_RAN" in result.stdout
|