summaryrefslogtreecommitdiffstats
path: root/test/t/conftest.py
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 16:24:27 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 16:24:27 +0000
commit6c18848a903eb3ee06dccd915859ce64195c257c (patch)
treeea0fe36eb5e6f40e0a1f765d44c4b0c0b2bfb089 /test/t/conftest.py
parentInitial commit. (diff)
downloadbash-completion-6c18848a903eb3ee06dccd915859ce64195c257c.tar.xz
bash-completion-6c18848a903eb3ee06dccd915859ce64195c257c.zip
Adding upstream version 1:2.11.upstream/1%2.11
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'test/t/conftest.py')
-rw-r--r--test/t/conftest.py637
1 files changed, 637 insertions, 0 deletions
diff --git a/test/t/conftest.py b/test/t/conftest.py
new file mode 100644
index 0000000..5c1603d
--- /dev/null
+++ b/test/t/conftest.py
@@ -0,0 +1,637 @@
+import difflib
+import os
+import re
+import shlex
+import subprocess
+import time
+from typing import Callable, Iterable, Iterator, List, Optional, Tuple
+
+import pexpect
+import pytest
+
+PS1 = "/@"
+MAGIC_MARK = "__MaGiC-maRKz!__"
+
+
+def find_unique_completion_pair(
+ items: Iterable[str],
+) -> Optional[Tuple[str, str]]:
+ result = None
+ bestscore = 0
+ sitems = sorted(set(items))
+ for i in range(len(sitems)):
+ cur = sitems[i]
+ curlen = len(cur)
+ prv = sitems[i - 1] if i != 0 else ""
+ prvlen = len(prv)
+ nxt = sitems[i + 1] if i < len(sitems) - 1 else ""
+ nxtlen = len(nxt)
+ diffprv = prv == ""
+ diffnxt = nxt == ""
+ # Analyse each item of the list and look for the minimum length of the
+ # partial prefix which is distinct from both nxt and prv. The list
+ # is sorted so the prefix will be unique in the entire list.
+ for j in range(curlen):
+ curchar = cur[j]
+ if not diffprv and (j >= prvlen or prv[j] != curchar):
+ diffprv = True
+ if not diffnxt and (j >= nxtlen or nxt[j] != curchar):
+ diffnxt = True
+ if diffprv and diffnxt:
+ break
+ # At the end of the loop, j is the index of last character of
+ # the unique partial prefix. The length is one plus that.
+ parlen = j + 1
+ if parlen >= curlen:
+ continue
+ # Try to find the most "readable pair"; look for a long pair where
+ # part is about half of full.
+ if parlen < curlen / 2:
+ parlen = int(curlen / 2)
+ score = curlen - parlen
+ if score > bestscore:
+ bestscore = score
+ result = (cur[:parlen], cur)
+ return result
+
+
+@pytest.fixture(scope="class")
+def output_sort_uniq(bash: pexpect.spawn) -> Callable[[str], List[str]]:
+ def _output_sort_uniq(command: str) -> List[str]:
+ return sorted(
+ set( # weed out possible duplicates
+ assert_bash_exec(bash, command, want_output=True).split()
+ )
+ )
+
+ return _output_sort_uniq
+
+
+@pytest.fixture(scope="class")
+def part_full_user(
+ bash: pexpect.spawn, output_sort_uniq: Callable[[str], List[str]]
+) -> Optional[Tuple[str, str]]:
+ res = output_sort_uniq("compgen -u")
+ pair = find_unique_completion_pair(res)
+ if not pair:
+ pytest.skip("No suitable test user found")
+ return pair
+
+
+@pytest.fixture(scope="class")
+def part_full_group(
+ bash: pexpect.spawn, output_sort_uniq: Callable[[str], List[str]]
+) -> Optional[Tuple[str, str]]:
+ res = output_sort_uniq("compgen -g")
+ pair = find_unique_completion_pair(res)
+ if not pair:
+ pytest.skip("No suitable test user found")
+ return pair
+
+
+@pytest.fixture(scope="class")
+def hosts(bash: pexpect.spawn) -> List[str]:
+ output = assert_bash_exec(bash, "compgen -A hostname", want_output=True)
+ return sorted(set(output.split() + _avahi_hosts(bash)))
+
+
+@pytest.fixture(scope="class")
+def avahi_hosts(bash: pexpect.spawn) -> List[str]:
+ return _avahi_hosts(bash)
+
+
+def _avahi_hosts(bash: pexpect.spawn) -> List[str]:
+ output = assert_bash_exec(
+ bash,
+ "! type avahi-browse &>/dev/null || "
+ "avahi-browse -cpr _workstation._tcp 2>/dev/null "
+ "| command grep ^= | cut -d';' -f7",
+ want_output=None,
+ )
+ return sorted(set(output.split()))
+
+
+@pytest.fixture(scope="class")
+def known_hosts(bash: pexpect.spawn) -> List[str]:
+ output = assert_bash_exec(
+ bash,
+ '_known_hosts_real ""; '
+ r'printf "%s\n" "${COMPREPLY[@]}"; unset COMPREPLY',
+ want_output=True,
+ )
+ return sorted(set(output.split()))
+
+
+@pytest.fixture(scope="class")
+def user_home(bash: pexpect.spawn) -> Tuple[str, str]:
+ user = assert_bash_exec(
+ bash, 'id -un 2>/dev/null || echo "$USER"', want_output=True
+ ).strip()
+ home = assert_bash_exec(bash, 'echo "$HOME"', want_output=True).strip()
+ return (user, home)
+
+
+def partialize(
+ bash: pexpect.spawn, items: Iterable[str]
+) -> Tuple[str, List[str]]:
+ """
+ Get list of items starting with the first char of first of items.
+
+ Disregard items starting with a COMP_WORDBREAKS character
+ (e.g. a colon ~ IPv6 address), they are special cases requiring
+ special tests.
+ """
+ first_char = None
+ comp_wordbreaks = assert_bash_exec(
+ bash,
+ 'printf "%s" "$COMP_WORDBREAKS"',
+ want_output=True,
+ want_newline=False,
+ )
+ partial_items = []
+ for item in sorted(items):
+ if first_char is None:
+ if item[0] not in comp_wordbreaks:
+ first_char = item[0]
+ partial_items.append(item)
+ elif item.startswith(first_char):
+ partial_items.append(item)
+ else:
+ break
+ if first_char is None:
+ pytest.skip("Could not generate partial items list from %s" % items)
+ # superfluous/dead code to assist mypy; pytest.skip always raises
+ assert first_char is not None
+ return first_char, partial_items
+
+
+@pytest.fixture(scope="class")
+def bash(request) -> pexpect.spawn:
+
+ logfile = None
+ if os.environ.get("BASHCOMP_TEST_LOGFILE"):
+ logfile = open(os.environ["BASHCOMP_TEST_LOGFILE"], "w")
+ testdir = os.path.abspath(
+ os.path.join(os.path.dirname(__file__), os.pardir)
+ )
+ env = os.environ.copy()
+ env.update(
+ dict(
+ SRCDIR=testdir, # TODO needed at least by bashrc
+ SRCDIRABS=testdir, # TODO needed?
+ PS1=PS1,
+ INPUTRC="%s/config/inputrc" % testdir,
+ TERM="dumb",
+ LC_COLLATE="C", # to match Python's default locale unaware sort
+ )
+ )
+
+ fixturesdir = os.path.join(testdir, "fixtures")
+ os.chdir(fixturesdir)
+
+ # Start bash
+ bash = pexpect.spawn(
+ "%s --norc" % os.environ.get("BASHCOMP_TEST_BASH", "bash"),
+ maxread=os.environ.get("BASHCOMP_TEST_PEXPECT_MAXREAD", 20000),
+ logfile=logfile,
+ cwd=fixturesdir,
+ env=env,
+ encoding="utf-8", # TODO? or native or...?
+ # FIXME: Tests shouldn't depend on dimensions, but it's difficult to
+ # expect robustly enough for Bash to wrap lines anywhere (e.g. inside
+ # MAGIC_MARK). Increase window width to reduce wrapping.
+ dimensions=(24, 160),
+ # TODO? codec_errors="replace",
+ )
+ bash.expect_exact(PS1)
+
+ # Load bashrc and bash_completion
+ assert_bash_exec(bash, "source '%s/config/bashrc'" % testdir)
+ assert_bash_exec(bash, "source '%s/../bash_completion'" % testdir)
+
+ # Use command name from marker if set, or grab from test filename
+ cmd = None # type: Optional[str]
+ cmd_found = False
+ marker = request.node.get_closest_marker("bashcomp")
+ if marker:
+ cmd = marker.kwargs.get("cmd")
+ cmd_found = "cmd" in marker.kwargs
+ # Run pre-test commands, early so they're usable in skipif
+ for pre_cmd in marker.kwargs.get("pre_cmds", []):
+ assert_bash_exec(bash, pre_cmd)
+ # Process skip and xfail conditions
+ skipif = marker.kwargs.get("skipif")
+ if skipif:
+ try:
+ assert_bash_exec(bash, skipif, want_output=None)
+ except AssertionError:
+ pass
+ else:
+ bash.close()
+ pytest.skip(skipif)
+ xfail = marker.kwargs.get("xfail")
+ if xfail:
+ try:
+ assert_bash_exec(bash, xfail, want_output=None)
+ except AssertionError:
+ pass
+ else:
+ pytest.xfail(xfail)
+ if not cmd_found:
+ match = re.search(
+ r"^test_(.+)\.py$", os.path.basename(str(request.fspath))
+ )
+ if match:
+ cmd = match.group(1)
+
+ request.cls.cmd = cmd
+
+ if (cmd_found and cmd is None) or is_testable(bash, cmd):
+ before_env = get_env(bash)
+ yield bash
+ # Not exactly sure why, but some errors leave bash in state where
+ # getting the env here would fail and trash our test output. So
+ # reset to a good state first (Ctrl+C, expect prompt).
+ bash.sendintr()
+ bash.expect_exact(PS1)
+ diff_env(
+ before_env,
+ get_env(bash),
+ marker.kwargs.get("ignore_env") if marker else "",
+ )
+
+ if marker:
+ for post_cmd in marker.kwargs.get("post_cmds", []):
+ assert_bash_exec(bash, post_cmd)
+
+ # Clean up
+ bash.close()
+ if logfile:
+ logfile.close()
+
+
+def is_testable(bash: pexpect.spawn, cmd: Optional[str]) -> bool:
+ if not cmd:
+ pytest.fail("Could not resolve name of command to test")
+ return False
+ if not load_completion_for(bash, cmd):
+ pytest.skip("No completion for command %s" % cmd)
+ return True
+
+
+def is_bash_type(bash: pexpect.spawn, cmd: Optional[str]) -> bool:
+ if not cmd:
+ return False
+ typecmd = "type %s &>/dev/null && echo -n 0 || echo -n 1" % cmd
+ bash.sendline(typecmd)
+ bash.expect_exact(typecmd + "\r\n")
+ result = bash.expect_exact(["0", "1"]) == 0
+ bash.expect_exact(PS1)
+ return result
+
+
+def load_completion_for(bash: pexpect.spawn, cmd: str) -> bool:
+ try:
+ # Allow __load_completion to fail so we can test completions
+ # that are directly loaded in bash_completion without a separate file.
+ assert_bash_exec(bash, "__load_completion %s || :" % cmd)
+ assert_bash_exec(bash, "complete -p %s &>/dev/null" % cmd)
+ except AssertionError:
+ return False
+ return True
+
+
+def assert_bash_exec(
+ bash: pexpect.spawn,
+ cmd: str,
+ want_output: Optional[bool] = False,
+ want_newline=True,
+) -> str:
+ """
+ :param want_output: if None, don't care if got output or not
+ """
+
+ # Send command
+ bash.sendline(cmd)
+ bash.expect_exact(cmd)
+
+ # Find prompt, output is before it
+ bash.expect_exact("%s%s" % ("\r\n" if want_newline else "", PS1))
+ output = bash.before
+
+ # Retrieve exit status
+ echo = "echo $?"
+ bash.sendline(echo)
+ got = bash.expect(
+ [
+ r"^%s\r\n(\d+)\r\n%s" % (re.escape(echo), re.escape(PS1)),
+ PS1,
+ pexpect.EOF,
+ pexpect.TIMEOUT,
+ ]
+ )
+ status = bash.match.group(1) if got == 0 else "unknown"
+
+ assert status == "0", 'Error running "%s": exit status=%s, output="%s"' % (
+ cmd,
+ status,
+ output,
+ )
+ if want_output is not None:
+ if output:
+ assert want_output, (
+ 'Unexpected output from "%s": exit status=%s, output="%s"'
+ % (cmd, status, output)
+ )
+ else:
+ assert not want_output, (
+ 'Expected output from "%s": exit status=%s, output="%s"'
+ % (cmd, status, output)
+ )
+
+ return output
+
+
+def get_env(bash: pexpect.spawn) -> List[str]:
+ return (
+ assert_bash_exec(
+ bash,
+ "{ (set -o posix ; set); declare -F; shopt -p; set -o; }",
+ want_output=True,
+ )
+ .strip()
+ .splitlines()
+ )
+
+
+def diff_env(before: List[str], after: List[str], ignore: str):
+ diff = [
+ x
+ for x in difflib.unified_diff(before, after, n=0, lineterm="")
+ # Remove unified diff markers:
+ if not re.search(r"^(---|\+\+\+|@@ )", x)
+ # Ignore variables expected to change:
+ and not re.search("^[-+](_|PPID|BASH_REMATCH|OLDPWD)=", x)
+ # Ignore likely completion functions added by us:
+ and not re.search(r"^\+declare -f _.+", x)
+ # ...and additional specified things:
+ and not re.search(ignore or "^$", x)
+ ]
+ # For some reason, COMP_WORDBREAKS gets added to the list after
+ # saving. Remove its changes, and note that it may take two lines.
+ for i in range(0, len(diff)):
+ if re.match("^[-+]COMP_WORDBREAKS=", diff[i]):
+ if i < len(diff) and not re.match(r"^\+[\w]+=", diff[i + 1]):
+ del diff[i + 1]
+ del diff[i]
+ break
+ assert not diff, "Environment should not be modified"
+
+
+class CompletionResult(Iterable[str]):
+ """
+ Class to hold completion results.
+ """
+
+ def __init__(self, output: Optional[str] = None):
+ """
+ :param output: All completion output as-is.
+ """
+ self.output = output or ""
+
+ def endswith(self, suffix: str) -> bool:
+ return self.output.endswith(suffix)
+
+ def startswith(self, prefix: str) -> bool:
+ return self.output.startswith(prefix)
+
+ def _items(self) -> List[str]:
+ return [x.strip() for x in self.output.strip().splitlines()]
+
+ def __eq__(self, expected: object) -> bool:
+ """
+ Returns True if completion contains expected items, and no others.
+
+ Defining __eq__ this way is quite ugly, but facilitates concise
+ testing code.
+ """
+ if isinstance(expected, str):
+ expiter = [expected] # type: Iterable
+ elif not isinstance(expected, Iterable):
+ return False
+ else:
+ expiter = expected
+ return self._items() == expiter
+
+ def __contains__(self, item: str) -> bool:
+ return item in self._items()
+
+ def __iter__(self) -> Iterator[str]:
+ return iter(self._items())
+
+ def __len__(self) -> int:
+ return len(self._items())
+
+ def __repr__(self) -> str:
+ return "<CompletionResult %s>" % self._items()
+
+
+def assert_complete(
+ bash: pexpect.spawn, cmd: str, **kwargs
+) -> CompletionResult:
+ skipif = kwargs.get("skipif")
+ if skipif:
+ try:
+ assert_bash_exec(bash, skipif, want_output=None)
+ except AssertionError:
+ pass
+ else:
+ pytest.skip(skipif)
+ xfail = kwargs.get("xfail")
+ if xfail:
+ try:
+ assert_bash_exec(bash, xfail, want_output=None)
+ except AssertionError:
+ pass
+ else:
+ pytest.xfail(xfail)
+ cwd = kwargs.get("cwd")
+ if cwd:
+ assert_bash_exec(bash, "cd '%s'" % cwd)
+ env_prefix = "_BASHCOMP_TEST_"
+ env = kwargs.get("env", {})
+ if env:
+ # Back up environment and apply new one
+ assert_bash_exec(
+ bash,
+ " ".join('%s%s="${%s-}"' % (env_prefix, k, k) for k in env.keys()),
+ )
+ assert_bash_exec(
+ bash,
+ "export %s" % " ".join("%s=%s" % (k, v) for k, v in env.items()),
+ )
+ try:
+ bash.send(cmd + "\t")
+ # Sleep a bit if requested, to avoid `.*` matching too early
+ time.sleep(kwargs.get("sleep_after_tab", 0))
+ bash.expect_exact(cmd)
+ bash.send(MAGIC_MARK)
+ got = bash.expect(
+ [
+ # 0: multiple lines, result in .before
+ r"\r\n" + re.escape(PS1 + cmd) + ".*" + re.escape(MAGIC_MARK),
+ # 1: no completion
+ r"^" + re.escape(MAGIC_MARK),
+ # 2: on same line, result in .match
+ r"^([^\r]+)%s$" % re.escape(MAGIC_MARK),
+ pexpect.EOF,
+ pexpect.TIMEOUT,
+ ]
+ )
+ if got == 0:
+ output = bash.before
+ if output.endswith(MAGIC_MARK):
+ output = bash.before[: -len(MAGIC_MARK)]
+ result = CompletionResult(output)
+ elif got == 2:
+ output = bash.match.group(1)
+ result = CompletionResult(output)
+ else:
+ # TODO: warn about EOF/TIMEOUT?
+ result = CompletionResult()
+ finally:
+ bash.sendintr()
+ bash.expect_exact(PS1)
+ if env:
+ # Restore environment, and clean up backup
+ # TODO: Test with declare -p if a var was set, backup only if yes, and
+ # similarly restore only backed up vars. Should remove some need
+ # for ignore_env.
+ assert_bash_exec(
+ bash,
+ "export %s"
+ % " ".join(
+ '%s="$%s%s"' % (k, env_prefix, k) for k in env.keys()
+ ),
+ )
+ assert_bash_exec(
+ bash,
+ "unset -v %s"
+ % " ".join("%s%s" % (env_prefix, k) for k in env.keys()),
+ )
+ if cwd:
+ assert_bash_exec(bash, "cd - >/dev/null")
+ return result
+
+
+@pytest.fixture
+def completion(request, bash: pexpect.spawn) -> CompletionResult:
+ marker = request.node.get_closest_marker("complete")
+ if not marker:
+ return CompletionResult()
+ for pre_cmd in marker.kwargs.get("pre_cmds", []):
+ assert_bash_exec(bash, pre_cmd)
+ cmd = getattr(request.cls, "cmd", None)
+ if marker.kwargs.get("require_longopt"):
+ # longopt completions require both command presence and that it
+ # responds something useful to --help
+ if "require_cmd" not in marker.kwargs:
+ marker.kwargs["require_cmd"] = True
+ if "xfail" not in marker.kwargs:
+ marker.kwargs["xfail"] = (
+ "! %s --help &>/dev/null || "
+ "! %s --help 2>&1 | command grep -qF -- --help"
+ ) % ((cmd,) * 2)
+ if marker.kwargs.get("require_cmd") and not is_bash_type(bash, cmd):
+ pytest.skip("Command not found")
+
+ if "trail" in marker.kwargs:
+ return assert_complete_at_point(
+ bash, cmd=marker.args[0], trail=marker.kwargs["trail"]
+ )
+
+ return assert_complete(bash, marker.args[0], **marker.kwargs)
+
+
+def assert_complete_at_point(
+ bash: pexpect.spawn, cmd: str, trail: str
+) -> CompletionResult:
+ # TODO: merge to assert_complete
+ fullcmd = "%s%s%s" % (
+ cmd,
+ trail,
+ "\002" * len(trail),
+ ) # \002 = ^B = cursor left
+ bash.send(fullcmd + "\t")
+ bash.send(MAGIC_MARK)
+ bash.expect_exact(fullcmd.replace("\002", "\b"))
+
+ got = bash.expect_exact(
+ [
+ # 0: multiple lines, result in .before
+ PS1 + fullcmd.replace("\002", "\b"),
+ # 1: no completion
+ MAGIC_MARK,
+ pexpect.EOF,
+ pexpect.TIMEOUT,
+ ]
+ )
+ if got == 0:
+ output = bash.before
+ result = CompletionResult(output)
+
+ # At this point, something weird happens. For most test setups, as
+ # expected (pun intended!), MAGIC_MARK follows as is. But for some
+ # others (e.g. CentOS 6, Ubuntu 14 test containers), we get MAGIC_MARK
+ # one character a time, followed each time by trail and the corresponding
+ # number of \b's. Don't know why, but accept it until/if someone finds out.
+ # Or just be fine with it indefinitely, the visible and practical end
+ # result on a terminal is the same anyway.
+ repeat = "(%s%s)?" % (re.escape(trail), "\b" * len(trail))
+ fullexpected = "".join(
+ "%s%s" % (re.escape(x), repeat) for x in MAGIC_MARK
+ )
+ bash.expect(fullexpected)
+ else:
+ # TODO: warn about EOF/TIMEOUT?
+ result = CompletionResult()
+
+ return result
+
+
+def in_container() -> bool:
+ try:
+ container = subprocess.check_output(
+ "virt-what || systemd-detect-virt --container",
+ stderr=subprocess.DEVNULL,
+ shell=True,
+ ).strip()
+ except subprocess.CalledProcessError:
+ container = b""
+ if container and container != b"none":
+ return True
+ if os.path.exists("/.dockerenv"):
+ return True
+ try:
+ with open("/proc/1/environ", "rb") as f:
+ # LXC, others?
+ if any(
+ x.startswith(b"container=") for x in f.readline().split(b"\0")
+ ):
+ return True
+ except OSError:
+ pass
+ return False
+
+
+class TestUnitBase:
+ def _test_unit(
+ self, func, bash, comp_words, comp_cword, comp_line, comp_point, arg=""
+ ):
+ assert_bash_exec(
+ bash,
+ "COMP_WORDS=%s COMP_CWORD=%d COMP_LINE=%s COMP_POINT=%d"
+ % (comp_words, comp_cword, shlex.quote(comp_line), comp_point),
+ )
+ output = assert_bash_exec(bash, func % arg, want_output=True)
+ return output.strip()