def socrates_ub_update_i(
lab: typing.Optional[linux.LinuxShell] = None,
uboot: typing.Optional[board.UBootShell] = None,
interactive = True,
) -> None:
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
if uboot is not None:
ub = uboot
else:
b = cx.enter_context(tbot.acquire_board(lh))
ub = cx.enter_context(tbot.acquire_uboot(b))
ret = ub.exec("ping", "192.168.1.1")
while ret[0] != 0:
ret = ub.exec("ping", "192.168.1.1")
if "restore_old_ub" in tbot.flags:
tbot.log.message("restore old U-Boot")
ub.env("uboot_addr", "FFFA0000")
ub.env("uboot_file", "socrates-abb/20190627/socrates-u-boot.bin-voncajus")
else:
ub.env("uboot_addr", "FFF60000")
ub.env("uboot_file", f"socrates-abb/{b.date}/u-boot-socrates.bin")
ub.env("update_uboot", "tftp 110000 ${uboot_file};protect off ${uboot_addr} ffffffff;era ${uboot_addr} ffffffff;cp.b 110000 ${uboot_addr} ${filesize}")
ub.exec0("printenv")
ub.exec0("run", "update_uboot")
if interactive:
ub.interactive()
def selftest_tc_git_checkout(lab: typing.Optional[linux.LabHost] = None,) -> None:
with lab or tbot.acquire_lab() as lh:
remote = git_prepare(lh)
target = lh.workdir / "selftest-git-checkout"
if target.exists():
lh.exec0("rm", "-rf", target)
tbot.log.message("Cloning repo ...")
repo = git.GitRepository(target, remote)
assert (repo / "README.md").is_file()
assert not (repo / "file2.md").is_file()
tbot.log.message("Make repo dirty ...")
lh.exec0("echo", "Test 123", stdout=repo / "file.txt")
repo = git.GitRepository(target, remote, clean=False)
assert (repo / "file.txt").is_file()
repo = git.GitRepository(target, remote, clean=True)
assert not (repo / "file.txt").is_file()
tbot.log.message("Add dirty commit ...")
lh.exec0("echo", "Test 123", stdout=repo / "file.txt")
repo.add(repo / "file.txt")
repo.commit("Add file.txt", author="tbot Selftest <none@none>")
repo = git.GitRepository(target, remote, clean=False)
assert (repo / "file.txt").is_file()
repo = git.GitRepository(target, remote, clean=True)
assert not (repo / "file.txt").is_file()
lh.exec0("rm", "-rf", target)
def selftest_path_integrity(
lab: typing.Optional[selftest.SelftestHost] = None) -> None:
"""Test if using a path on the wrong host fails."""
with lab or selftest.SelftestHost() as lh:
p = lh.workdir / "folder" / "file.txt"
with tbot.acquire_lab() as lh2:
raised = False
try:
# mypy detects that this is wrong
lh2.exec0("echo", p) # type: ignore
# TODO: Proper exception type
except: # noqa: E722
raised = True
assert raised
# It is ok to clone a machine and reuse the path
with lh.clone() as lh3:
lh3.exec0("echo", p)
lh.exec0("mkdir", "-p", p.parent)
assert p.parent.is_dir()
lh.exec0("uname", "-a", linux.RedirStdout(p))
assert p.is_file()
lh.exec0("rm", "-r", p.parent)
assert not p.exists()
assert not p.parent.exists()
def selftest_board_uboot_noab(
lab: typing.Optional[tbot.selectable.LabHost] = None
) -> None:
"""Test if tbot intercepts U-Boot correctly without autoboot."""
class TestBoardUBootNoAB(board.UBootMachine[TestBoard]):
"""Dummy Board UBoot."""
autoboot_prompt = None
prompt = "Test-U-Boot> "
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
b = cx.enter_context(TestBoard(lh, has_autoboot=False))
ub = cx.enter_context(TestBoardUBootNoAB(b))
ub.exec0("version")
env = ub.exec0("printenv").strip().split("\n")
for line in env[:-1]:
if line != "" and line[0].isalnum():
assert "=" in line, repr(line)
out = ub.exec0("echo", board.F("0x{}", str(1234))).strip()
assert out == "0x1234", repr(out)
mach.selftest_machine_shell(ub)
def ari_ub_check_multi_dtb_select(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
with lab or tbot.acquire_lab() as lh:
with contextlib.ExitStack() as bx:
b = bx.enter_context(tbot.acquire_board(lh))
with contextlib.ExitStack() as cx:
ub = cx.enter_context(tbot.acquire_uboot(b))
cur_panel = ge.ub_get_var(ub, "panel")
old_panel = cur_panel
check_panel(ub, cur_panel)
cur_panel = switch_panel(ub, cur_panel)
ub.ch.sendline("res")
with contextlib.ExitStack() as cx:
ub = cx.enter_context(tbot.acquire_uboot(b))
cur_panel = ge.ub_get_var(ub, "panel")
if old_panel == cur_panel:
raise RuntimeError(
f"{cur_panel} == {old_panel}, should change")
old_panel = cur_panel
check_panel(ub, cur_panel)
cur_panel = switch_panel(ub, cur_panel)
ub.ch.sendline("res")
with contextlib.ExitStack() as cx:
ub = cx.enter_context(tbot.acquire_uboot(b))
cur_panel = ge.ub_get_var(ub, "panel")
if old_panel == cur_panel:
raise RuntimeError(
f"{cur_panel} == {old_panel}, should change")
check_panel(ub, cur_panel)
def socrates_ub_bdi_update(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubma: typing.Optional[board.UBootShell] = None,
) -> None:
with contextlib.ExitStack() as cx:
if lab is not None:
lh = lab
else:
lh = cx.enter_context(tbot.acquire_lab())
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
bd.bdi_connect(lh, b)
bd.bdi_reset_board()
bd.exec("era")
if "restore_old_ub" in tbot.flags:
bd.exec("prog", "0xfffa0000", f"socrates-abb/{b.date}/socrates-u-boot.bin-voncajus", "BIN")
else:
bd.exec("era", "0xfff60000")
bd.exec("prog", "0xfff60000", f"socrates-abb/{b.date}/u-boot-socrates.bin", "BIN")
bd.bdi_reset_board_run()
if ubma is not None:
ub = ubma
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
ub.interactive()
def ari_ub_check_version(
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
u-boot check if version on board is the same as in binary
"""
with lab or tbot.acquire_lab() as lh:
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
t = lh.tftp_dir / "u-boot-dtb.imx.signed"
#bin_vers = lh.exec0("strings", t, linux.Pipe, "grep", '"U-Boot 2"')
bin_vers = lh.exec0(
linux.Raw(
f"strings /tftpboot/aristainetos/tbot/u-boot-dtb.imx.signed | grep --color=never 'U-Boot 2'"
))
ub_vers = ub.exec0("version")
if bin_vers in ub_vers:
tbot.log.message(
tbot.log.c("Info: U-Boot version is the same").green)
else:
raise RuntimeError(f"{bin_vers} != {ub_vers}")
def selftest(lab: typing.Optional[linux.Lab] = None, ) -> None:
"""Run all selftests."""
with lab or tbot.acquire_lab() as lh:
tc.testsuite(
selftest_failing,
selftest_skipping,
selftest_uname,
selftest_user,
machine.selftest_machine_reentrant,
machine.selftest_machine_labhost_shell,
machine.selftest_machine_ssh_shell,
machine.selftest_machine_sshlab_shell,
path.selftest_path_stat,
path.selftest_path_integrity,
board_machine.selftest_board_power,
board_machine.selftest_board_uboot,
board_machine.selftest_board_uboot_noab,
board_machine.selftest_board_linux,
board_machine.selftest_board_linux_uboot,
board_machine.selftest_board_linux_standalone,
board_machine.selftest_board_linux_nopw,
board_machine.selftest_board_linux_bad_console,
testcase.selftest_with_lab,
testcase.selftest_with_uboot,
testcase.selftest_with_linux,
lab=lh,
)
def selftest_tc_git_bisect(lab: typing.Optional[linux.Lab] = None, ) -> None:
"""Test the git-bisect testcase."""
with lab or tbot.acquire_lab() as lh:
remote = git_prepare(lh)
target = lh.workdir / "selftest-git-bisect"
if target.exists():
lh.exec0("rm", "-rf", target)
repo = git.GitRepository(target, remote)
good = git_increment_commits(repo)
@tbot.testcase
def check_counter(repo: git.GitRepository) -> bool:
result = repo.host.exec("cat", repo / "counter.txt")
return result[0] == 0 and int(result[1].strip()) < 17
head = repo.symbolic_head
bad = repo.bisect(good=good, test=check_counter)
tbot.log.message(f"Bad commit is {bad}!")
repo.git0("show", bad, linux.Pipe, "cat")
new_head = repo.symbolic_head
assert (new_head == head
), f"Bisect didn't clean up ... ({new_head!r} != {head!r})"
lh.exec0("rm", "-rf", target)
def board_power(
lab: typing.Optional[tbot.selectable.LabHost] = None,
board: typing.Optional[board.Board] = None,
state='on',
) -> None:
"""
power on or off the board without acquiring console.
This is only hacky version, we should bring in this into
tbot.
"""
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
fl = tbot.flags
tbot.flags = {"no_console_check", "nopoweroff"}
b = cx.enter_context(board or tbot.acquire_board(lh))
tbot.flags = fl
if state == 'on':
b.poweron()
else:
b.poweroff()
tbot.flags = {"no_console_check", "nopoweroff"}
def selftest_board_uboot(lab: typing.Optional[tbot.selectable.LabHost] = None) -> None:
"""Test if tbot intercepts U-Boot correctly."""
with contextlib.ExitStack() as cx:
lh = cx.enter_context(lab or tbot.acquire_lab())
try:
b: board.Board = cx.enter_context(tbot.acquire_board(lh))
ub: board.UBootShell = cx.enter_context(
tbot.acquire_uboot(b) # type: ignore
)
except NotImplementedError:
b = cx.enter_context(TestBoard(lh))
ub = cx.enter_context(TestBoardUBoot(b))
ub.exec0("version")
env = ub.exec0("printenv").strip().split("\n")
for line in env[:-1]:
if line != "" and line[0].isalnum():
assert "=" in line, repr(line)
out = ub.exec0("echo", hex(0x1234)).strip()
assert out == "0x1234", repr(out)
mach.selftest_machine_shell(ub)
def selftest_board_linux_standalone(
lab: typing.Optional[tbot.selectable.LabHost] = None
) -> None:
"""Test linux booting standalone."""
class TestBoardLinuxStandalone(board.LinuxStandaloneMachine[TestBoard]):
username = "******"
password = None
login_prompt = "Autoboot: "
shell = linux.shell.Bash
with lab or tbot.acquire_lab() as lh:
tbot.log.message("Testing without UB ...")
with TestBoard(lh) as b:
with TestBoardLinuxStandalone(b) as lnx:
lnx.exec0("uname", "-a")
tbot.log.message("Testing with UB ...")
with TestBoard(lh) as b:
with TestBoardUBoot(b) as ub:
raised = False
try:
with TestBoardLinuxStandalone(ub) as lnx:
lnx.exec0("uname", "-a")
except RuntimeError:
raised = True
assert raised
def selftest_board_power(lab: typing.Optional[tbot.selectable.LabHost] = None) -> None:
"""Test if the board is powered on and off correctly."""
with lab or tbot.acquire_lab() as lh:
power_path = lh.workdir / "selftest_power"
if power_path.exists():
lh.exec0("rm", power_path)
tbot.log.message("Emulating a normal run ...")
assert not power_path.exists()
with TestBoard(lh):
assert power_path.exists()
assert not power_path.exists()
class TestException(Exception):
pass
tbot.log.message("Emulating a failing run ...")
try:
with TestBoard(lh):
assert power_path.exists()
tbot.log.message("raise TestException()")
raise TestException()
except TestException:
pass
assert not power_path.exists()
def selftest_user(lab: typing.Optional[linux.Lab] = None, ) -> None:
"""Test lab-host variable expansion."""
with lab or tbot.acquire_lab() as lh:
lh.exec0("echo", lh.env("USER"))
user = lh.env("USER")
assert "\n" not in user, "Malformed username?"
def ari_ub_sign(lab: typing.Optional[linux.LinuxShell] = None, ) -> None:
"""
sign u-boot
"""
with lab or tbot.acquire_lab() as lh:
for f in result_files:
if "u-boot" in f:
# copy file to sign path
s = lh.tftp_dir / f
t = lh.sign_dir / f
tbot.tc.shell.copy(s, t)
lh.exec0("cd", lh.sign_dir)
lh.exec0("pwd")
lh.exec0("./cst", "--o", "u-boot-dtb_csf.bin", "--i",
"u-boot-dtb.csf")
lh.exec0(
linux.Raw(
"cat u-boot-dtb.imx u-boot-dtb_csf.bin > u-boot-dtb.imx.signed"
))
s = lh.sign_dir / "u-boot-dtb.imx.signed"
t = lh.tftp_dir / "u-boot-dtb.imx.signed"
tbot.tc.shell.copy(s, t)
# cleanup
lh.exec0("rm", "u-boot-dtb_csf.bin")
lh.exec0("rm", "u-boot-dtb.imx.signed")
def install():
""" Flash the u-boot-image to the board """
with contextlib.ExitStack() as cx:
lab = cx.enter_context(tbot.acquire_lab())
host = typing.cast(linux.Builder, cx.enter_context(lab.build()))
builder = getattr(tbot.selectable.UBootMachine, "build")
path = builder.do_repo_path(host)
builder.install(host, path._local_str())
def selftest_with_lab(lab: typing.Optional[linux.Lab] = None) -> None:
"""Test the tbot.with_lab decorator."""
with lab or tbot.acquire_lab() as lh:
# Call without parameter
selftest_decorated_lab()
# Call with parameter
selftest_decorated_lab(lh)
def selftest_machine_reentrant(lab: typing.Optional[linux.LabHost] = None,) -> None:
"""Test if a machine can be entered multiple times."""
with lab or tbot.acquire_lab() as lh:
with lh as h1:
assert h1.exec0("echo", "FooBar") == "FooBar\n"
with lh as h2:
assert h2.exec0("echo", "FooBar2") == "FooBar2\n"
def selftest_machine_labhost_shell(
lab: typing.Optional[linux.LabHost] = None, ) -> None:
"""Test the LabHost's shell."""
with lab or tbot.acquire_lab() as lh:
selftest_machine_shell(lh)
selftest_machine_channel(lh.new_channel(), False)
selftest_machine_channel(lh.new_channel(), True)
def ub_check_version(
resfiles: list,
lab: typing.Optional[linux.LinuxShell] = None,
board: typing.Optional[board.Board] = None,
ubx: typing.Optional[board.UBootShell] = None,
) -> None:
"""
check if installed U-Boot version is the same as in
tftp directory.
"""
with lab or tbot.acquire_lab() as lh:
r = get_path(lh.tftp_root_path) + "/" + get_path(lh.tftp_dir_board)
spl_vers = None
ub_vers = None
splfiles = ["MLO", "SPL"]
ubfiles = ["u-boot.img", "u-boot-socrates.bin", "u-boot.bin", "u-boot-dtb.imx", "u-boot-dtb.bin"]
for f in resfiles:
if spl_vers == None:
if any(s in f for s in splfiles):
log_event.doc_begin("get_spl_vers")
spl_vers = lh.exec0(linux.Raw(f'strings {r}/{f} | grep --color=never "U-Boot SPL 2"'))
spl_vers = spl_vers.strip()
log_event.doc_tag("ub_spl_new_version", spl_vers)
log_event.doc_end("get_spl_vers")
tbot.log.message(tbot.log.c(f"found in image U-Boot SPL version {spl_vers}").green)
if ub_vers == None:
if any(s in f for s in ubfiles):
log_event.doc_begin("get_ub_vers")
ub_vers = lh.exec0(linux.Raw(f'strings {r}/{f} | grep --color=never "U-Boot 2"'))
for l in ub_vers.split('\n'):
if ":" in l:
ub_vers = l.strip()
if ub_vers[0] == 'V':
ub_vers = ub_vers[1:]
log_event.doc_tag("ub_ub_new_version", ub_vers)
log_event.doc_end("get_ub_vers")
tbot.log.message(tbot.log.c(f"found in image U-Boot version {ub_vers}").green)
with contextlib.ExitStack() as cx:
if board is not None:
b = board
else:
b = cx.enter_context(tbot.acquire_board(lh))
if ubx is not None:
ub = ubx
else:
ub = cx.enter_context(tbot.acquire_uboot(b))
if spl_vers != None:
if spl_vers not in ub.bootlog:
raise RuntimeError(f"{spl_vers} not found.")
tbot.log.message(tbot.log.c(f"found U-Boot SPL version {spl_vers} installed").green)
if ub_vers == None:
raise RuntimeError(f"No U-Boot version defined")
else:
if ub_vers not in ub.bootlog:
raise RuntimeError(f"{ub_vers} not found.")
tbot.log.message(tbot.log.c(f"found U-Boot version {ub_vers} installed").green)
def selftest_tc(lab: typing.Optional[linux.LabHost] = None, ) -> None:
"""Test builtin testcases."""
with lab or tbot.acquire_lab() as lh:
tc.testsuite(
selftest_tc_git_checkout, # noqa: F405
selftest_tc_git_am, # noqa: F405
selftest_tc_git_bisect, # noqa: F405
selftest_tc_shell_copy, # noqa: F405
lab=lh,
)
def getcpu(mach: typing.Optional[linux.LinuxMachine] = None, ) -> None:
with contextlib.ExitStack() as cx:
if mach is None:
lh = cx.enter_context(tbot.acquire_lab())
b = cx.enter_context(tbot.acquire_board(lh))
lnx = cx.enter_context(tbot.acquire_linux(b))
else:
lnx = mach
lnx.exec0("cat", "/proc/cpuinfo")
def gettarget(mach: typing.Optional[linux.LinuxMachine] = None, ) -> None:
with contextlib.ExitStack() as cx:
if mach is None:
lh = cx.enter_context(tbot.acquire_lab())
b = cx.enter_context(tbot.acquire_board(lh))
lnx = cx.enter_context(tbot.acquire_linux(b))
else:
lnx = mach
tc.testsuite(getcpu, getlinuxversion, getyoctoversion, mach=lnx)
def selftest_tc_kconfig(lab: typing.Optional[linux.Lab] = None) -> None:
"""Test kconig setting."""
with lab or tbot.acquire_lab() as lh:
conf = lh.workdir / "selftest-kconfig"
for i in range(4):
lh.exec0(
"echo",
"""\
# tbot-selftest kconfig file
# DO NOT EDIT! (Deleting is ok, though)
CONFIG_FOO=y
CONFIG_BAR=m
# CONFIG_BAZ is not set
CONFIG_STRING="a happy string"
CONFIG_HEX=0xC0FFEE""",
linux.RedirStdout(conf),
)
if i == 0:
tbot.log.message("Enabling all ...")
kconfig.enable(conf, "CONFIG_FOO")
kconfig.enable(conf, "CONFIG_BAR")
kconfig.enable(conf, "CONFIG_BAZ")
assert (lh.exec0("grep", "-c", "-E", "CONFIG_(FOO|BAR|BAZ)=y",
conf).strip() == "3")
elif i == 1:
tbot.log.message("Disabling all ...")
kconfig.disable(conf, "CONFIG_FOO")
kconfig.disable(conf, "CONFIG_BAR")
kconfig.disable(conf, "CONFIG_BAZ")
assert (lh.exec0("grep", "-c", "-E", "# CONFIG_(FOO|BAR|BAZ)",
conf).strip() == "3")
assert (lh.exec("grep", "-c", "-E", "^CONFIG_(FOO|BAR|BAZ)",
conf)[1].strip() == "0")
elif i == 2:
tbot.log.message("Moduling all ...")
kconfig.module(conf, "CONFIG_FOO")
kconfig.module(conf, "CONFIG_BAR")
kconfig.module(conf, "CONFIG_BAZ")
assert (lh.exec0("grep", "-c", "-E", "CONFIG_(FOO|BAR|BAZ)=m",
conf).strip() == "3")
elif i == 3:
tbot.log.message("Testing values ...")
kconfig.set_string_value(conf, "CONFIG_STRING", "abcdef")
kconfig.set_hex_value(conf, "CONFIG_HEX", 0xDEADBEEF)
assert (lh.exec0("grep", "-c", 'CONFIG_STRING="abcdef"',
conf).strip() == "1")
assert (lh.exec0("grep", "-c", "CONFIG_HEX=0xdeadbeef",
conf).strip() == "1")
def selftest_tc_shell_copy(
lab: typing.Optional[linux.LabHost] = None, ) -> None:
"""Test ``shell.copy``."""
def do_test(a: linux.Path, b: linux.Path, msg: str) -> None:
if b.exists():
b.host.exec0("rm", b)
a.host.exec0("echo", msg, stdout=a)
shell.copy(a, b)
out = b.host.exec0("cat", b).strip()
assert out == msg, repr(out) + " != " + repr(msg)
with lab or tbot.acquire_lab() as lh:
tbot.log.message("Test copying a file on the same host ...")
do_test(
lh.workdir / ".selftest-copy-local1",
lh.workdir / ".selftest-copy-local2",
"Copy locally",
)
if minisshd.check_minisshd(lh):
with minisshd.minisshd(lh) as ssh:
tbot.log.message(
"Test downloading a file from an ssh host ...")
do_test(
ssh.workdir / ".selftest-copy-ssh1",
lh.workdir / ".selftest-copy-ssh2",
"Download via SCP",
)
tbot.log.message("Test uploading a file to an ssh host ...")
do_test(
lh.workdir / ".selftest-copy-ssh1",
ssh.workdir / ".selftest-copy-ssh2",
"Upload via SCP",
)
with minisshd.MiniSSHLabHost(ssh.port) as sl:
tbot.log.message(
"Test downloading a file from an ssh lab ...")
do_test(
sl.workdir / ".selftest-copy-ssh4",
lh.workdir / ".selftest-copy-ssh3",
"Download via SCP Lab",
)
tbot.log.message("Test uploading a file to an ssh lab ...")
do_test(
lh.workdir / ".selftest-copy-ssh3",
sl.workdir / ".selftest-copy-ssh4",
"Upload via SCP Lab",
)
else:
tbot.log.message(tbot.log.c("Skip").yellow.bold + " ssh tests.")
def getyoctoversion(
mach: typing.Optional[linux.LinuxMachine] = None, ) -> None:
with contextlib.ExitStack() as cx:
if mach is None:
lh = cx.enter_context(tbot.acquire_lab())
b = cx.enter_context(tbot.acquire_board(lh))
lnx = cx.enter_context(tbot.acquire_linux(b))
else:
lnx = mach
lnx.exec0("cat", "/etc/os_release")
def yo_repo_sync(
self,
lab: typing.Optional[linux.LinuxShell] = None,
build: typing.
Optional[
linux.LinuxShell] = None, # besser check if it is a build machine!
) -> None:
with lab or tbot.acquire_lab() as lh:
with build or lh.build() as bh:
self.cd_yocto_workdir(bh)
self.repo_sync(bh)
def selftest_machine_labhost_shell(
lab: typing.Optional[linux.Lab] = None, ) -> None:
"""Test the LabHost's shell."""
with lab or tbot.acquire_lab() as lh:
selftest_machine_shell(lh)
with lh.clone() as l2:
selftest_machine_channel(l2.ch, False)
with lh.clone() as l2:
selftest_machine_channel(l2.ch, True)
def selftest_path_integrity(lab: typing.Optional[linux.LabHost] = None,) -> None:
with lab or tbot.acquire_lab() as lh:
p = lh.workdir / "folder" / "file.txt"
with tbot.acquire_lab() as lh2:
raised = False
try:
# mypy detects that this is wrong
lh2.exec0("echo", p) # type: ignore
except machine.WrongHostException:
raised = True
assert raised
lh.exec0("mkdir", "-p", p.parent)
assert p.parent.is_dir()
lh.exec0("uname", "-a", stdout=p)
assert p.is_file()
lh.exec0("rm", "-r", p.parent)
assert not p.exists()
assert not p.parent.exists()
def selftest_machine_ssh_shell(lab: typing.Optional[linux.LabHost] = None,) -> None:
"""Test an SSH shell."""
from tbot.tc.selftest import minisshd
with lab or tbot.acquire_lab() as lh:
if minisshd.check_minisshd(lh):
with minisshd.minisshd(lh) as ssh:
selftest_machine_shell(ssh)
selftest_machine_channel(ssh._obtain_channel(), True)
else:
tbot.log.message(tbot.log.c("Skip").yellow.bold + " ssh tests.")
