buildroot/support/testing/tests/init/test_systemd.py

import infra.basetest
import re
from tests.init.base import InitSystemBase as InitSystemBase


# In the following tests, the read-only cases use the default settings,
# which historically used both a factory to populate a tmpfs on /var,
# and pre-populated /var at buildtime. Since these are the default
# settings, and they proved to generate a system that ultimately boots,
# we still want to keep testing that. See later, below, for the
# specialised test cases.

class InitSystemSystemdBase(InitSystemBase):
    config = \
        """
        BR2_arm=y
        BR2_cortex_a9=y
        BR2_ARM_ENABLE_VFP=y
        BR2_TOOLCHAIN_EXTERNAL=y
        BR2_TOOLCHAIN_EXTERNAL_BOOTLIN=y
        BR2_INIT_SYSTEMD=y
        BR2_TARGET_GENERIC_GETTY_PORT="ttyAMA0"
        # BR2_TARGET_ROOTFS_TAR is not set
        BR2_PER_PACKAGE_DIRECTORIES=y
        """

    def check_systemd(self, fs):
        if "BR2_LINUX_KERNEL=y" in self.config:
            self.start_emulator(fs, "zImage", "vexpress-v2p-ca9")
        else:
            self.start_emulator(fs)
        self.check_init("/lib/systemd/systemd")

        # Test there is no tainted flag.
        output, ret = self.emulator.run("systemctl --no-pager status")
        self.assertEqual(ret, 0, f"'systemctl status' failed with exit code {ret}, with:\n{output}")
        try:
            # 'support-ended' tainted flag is only set based on the
            # SUPPORT_END variable in /etc/os-release; as we don't set
            # it in Buildroot, we can't get that flag in the runtime
            # tests, even on our maintenance branches, so we don't need
            # to filter it out.
            tainted_flags = [
                "".join(line.split(":")[1:]).strip()
                for line in output
                if line.strip().startswith("Tainted: ")
            ][0]
            raise RuntimeError(f"Tainted flags: {tainted_flags}")
        except IndexError:
            # No tainted flag \o/
            pass

        # Test all units are OK
        output, _ = self.emulator.run("systemctl --no-pager --failed --no-legend")
        self.assertEqual(len(output), 0)

        # Test we can reach the DBus daemon
        self.assertRunOk("busctl --no-pager")

        # Test we can read at least one line from the journal
        output, _ = self.emulator.run("journalctl --no-pager --lines 1 --quiet")
        self.assertEqual(len(output), 1)

        # Check the network is up
        self.check_network("eth0")


class TestInitSystemSystemdRoNetworkd(InitSystemSystemdBase):
    config = InitSystemSystemdBase.config + \
        """
        BR2_SYSTEM_DHCP="eth0"
        # BR2_TARGET_GENERIC_REMOUNT_ROOTFS_RW is not set
        BR2_TARGET_ROOTFS_SQUASHFS=y
        """

    def test_run(self):
        self.check_systemd("squashfs")


class TestInitSystemSystemdRwNetworkd(InitSystemSystemdBase):
    config = InitSystemSystemdBase.config + \
        """
        BR2_SYSTEM_DHCP="eth0"
        BR2_TARGET_ROOTFS_EXT2=y
        """

    def test_run(self):
        self.check_systemd("ext2")


class TestInitSystemSystemdRoIfupdown(InitSystemSystemdBase):
    config = InitSystemSystemdBase.config + \
        """
        BR2_SYSTEM_DHCP="eth0"
        # BR2_PACKAGE_SYSTEMD_NETWORKD is not set
        # BR2_TARGET_GENERIC_REMOUNT_ROOTFS_RW is not set
        BR2_TARGET_ROOTFS_SQUASHFS=y
        """

    def test_run(self):
        self.check_systemd("squashfs")


class TestInitSystemSystemdRoIfupdownDbusbroker(TestInitSystemSystemdRoIfupdown):
    config = TestInitSystemSystemdRoIfupdown.config + \
        """
        BR2_PACKAGE_DBUS_BROKER=y
        """

    def test_run(self):
        # Parent class' test_run() method does exactly that, no more:
        self.check_systemd("squashfs")

        # Check that the dbus-broker daemon is running as non-root
        cmd = "find /proc/$(pidof dbus-broker) -maxdepth 1 -name exe -user dbus"
        out, _ = self.emulator.run(cmd)
        self.assertEqual(len(out), 1)


class TestInitSystemSystemdRoIfupdownDbusbrokerDbus(TestInitSystemSystemdRoIfupdownDbusbroker):
    config = TestInitSystemSystemdRoIfupdownDbusbroker.config + \
        """
        BR2_PACKAGE_DBUS=y
        """


class TestInitSystemSystemdRwIfupdown(InitSystemSystemdBase):
    config = InitSystemSystemdBase.config + \
        """
        BR2_SYSTEM_DHCP="eth0"
        # BR2_PACKAGE_SYSTEMD_NETWORKD is not set
        BR2_TARGET_ROOTFS_EXT2=y
        """

    def test_run(self):
        self.check_systemd("ext2")


class TestInitSystemSystemdRwIfupdownDbusbroker(TestInitSystemSystemdRwIfupdown):
    config = TestInitSystemSystemdRwIfupdown.config + \
        """
        BR2_PACKAGE_DBUS_BROKER=y
        """

    def test_run(self):
        # Parent class' test_run() method does exactly that, no more:
        self.check_systemd("ext2")

        # Check that the dbus-broker daemon is running as non-root
        cmd = "find /proc/$(pidof dbus-broker) -maxdepth 1 -name exe -user dbus"
        out, _ = self.emulator.run(cmd)
        self.assertEqual(len(out), 1)


class TestInitSystemSystemdRwIfupdownDbusbrokerDbus(TestInitSystemSystemdRwIfupdownDbusbroker):
    config = TestInitSystemSystemdRwIfupdownDbusbroker.config + \
        """
        BR2_PACKAGE_DBUS=y
        """


class TestInitSystemSystemdRoFull(InitSystemSystemdBase):
    config = InitSystemSystemdBase.config + \
        """
        BR2_SYSTEM_DHCP="eth0"
        # BR2_TARGET_GENERIC_REMOUNT_ROOTFS_RW is not set
        BR2_PACKAGE_SYSTEMD_JOURNAL_REMOTE=y
        BR2_PACKAGE_SYSTEMD_BACKLIGHT=y
        BR2_PACKAGE_SYSTEMD_BINFMT=y
        BR2_PACKAGE_SYSTEMD_COREDUMP=y
        BR2_PACKAGE_SYSTEMD_FIRSTBOOT=y
        BR2_PACKAGE_SYSTEMD_HIBERNATE=y
        BR2_PACKAGE_SYSTEMD_IMPORTD=y
        BR2_PACKAGE_SYSTEMD_LOCALED=y
        BR2_PACKAGE_SYSTEMD_LOGIND=y
        BR2_PACKAGE_SYSTEMD_MACHINED=y
        BR2_PACKAGE_SYSTEMD_POLKIT=y
        BR2_PACKAGE_SYSTEMD_QUOTACHECK=y
        BR2_PACKAGE_SYSTEMD_RANDOMSEED=y
        BR2_PACKAGE_SYSTEMD_RFKILL=y
        BR2_PACKAGE_SYSTEMD_SMACK_SUPPORT=y
        BR2_PACKAGE_SYSTEMD_SYSUSERS=y
        BR2_PACKAGE_SYSTEMD_VCONSOLE=y
        BR2_TARGET_ROOTFS_SQUASHFS=y
        """

    def test_run(self):
        self.check_systemd("squashfs")


class TestInitSystemSystemdRwFull(InitSystemSystemdBase):
    config = InitSystemSystemdBase.config + \
        """
        BR2_SYSTEM_DHCP="eth0"
        BR2_PACKAGE_SYSTEMD_JOURNAL_REMOTE=y
        BR2_PACKAGE_SYSTEMD_BACKLIGHT=y
        BR2_PACKAGE_SYSTEMD_BINFMT=y
        BR2_PACKAGE_SYSTEMD_COREDUMP=y
        BR2_PACKAGE_SYSTEMD_FIRSTBOOT=y
        BR2_PACKAGE_SYSTEMD_HIBERNATE=y
        BR2_PACKAGE_SYSTEMD_IMPORTD=y
        BR2_PACKAGE_SYSTEMD_LOCALED=y
        BR2_PACKAGE_SYSTEMD_LOGIND=y
        BR2_PACKAGE_SYSTEMD_MACHINED=y
        BR2_PACKAGE_SYSTEMD_POLKIT=y
        BR2_PACKAGE_SYSTEMD_QUOTACHECK=y
        BR2_PACKAGE_SYSTEMD_RANDOMSEED=y
        BR2_PACKAGE_SYSTEMD_RFKILL=y
        BR2_PACKAGE_SYSTEMD_SMACK_SUPPORT=y
        BR2_PACKAGE_SYSTEMD_SYSUSERS=y
        BR2_PACKAGE_SYSTEMD_VCONSOLE=y
        BR2_TARGET_ROOTFS_EXT2=y
        """

    def test_run(self):
        self.check_systemd("ext2")


# The following tests are all about read-only rootfs, and exercise either
# using an un-populated factory for /var, or an overlaysfs on top of a
# pre-populated /var. They all specialise the TestInitSystemSystemdRo*
# test cases above.


# Helper class for factory-based tests
class InitSystemSystemdBaseFactory():
    config = \
        """
        # BR2_INIT_SYSTEMD_POPULATE_TMPFILES is not set
        BR2_ROOTFS_OVERLAY="{}"
        """.format(infra.filepath("tests/init/systemd-factory"))

    def test_run(self):
        super().test_run()

        # This one must be executed on the target, to check that
        # the factory feature works as expected
        out, exit_code = self.emulator.run("cat /var/foo/bar")
        self.assertEqual(exit_code, 0)
        self.assertEqual(out[0], "foobar")

        # /var/foo/bar is from the /var factory
        _, exit_code = self.emulator.run("test -e /usr/share/factory/var/foo/bar")
        self.assertEqual(exit_code, 0)

        # We can write in /var/foo/bar
        _, exit_code = self.emulator.run("echo barfoo >/var/foo/bar")
        self.assertEqual(exit_code, 0)
        # ... and it contains the new content
        out, exit_code = self.emulator.run("cat /var/foo/bar")
        self.assertEqual(exit_code, 0)
        self.assertEqual(out[0], "barfoo")
        # ... but the factory is umodified
        out, exit_code = self.emulator.run("cat /usr/share/factory/var/foo/bar")
        self.assertEqual(exit_code, 0)
        self.assertEqual(out[0], "foobar")


class TestInitSystemSystemdRoNetworkdFactory(
    InitSystemSystemdBaseFactory,
    TestInitSystemSystemdRoNetworkd,
):
    config = InitSystemSystemdBaseFactory.config + \
        TestInitSystemSystemdRoNetworkd.config


class TestInitSystemSystemdRoIfupdownFactory(
    InitSystemSystemdBaseFactory,
    TestInitSystemSystemdRoIfupdown,
):
    config = InitSystemSystemdBaseFactory.config + \
        TestInitSystemSystemdRoIfupdown.config


class TestInitSystemSystemdRoIfupdownDbusbrokerFactory(
    InitSystemSystemdBaseFactory,
    TestInitSystemSystemdRoIfupdownDbusbroker,
):
    config = InitSystemSystemdBaseFactory.config + \
        TestInitSystemSystemdRoIfupdownDbusbroker.config


class TestInitSystemSystemdRoIfupdownDbusbrokerDbusFactory(
    InitSystemSystemdBaseFactory,
    TestInitSystemSystemdRoIfupdownDbusbrokerDbus,
):
    config = InitSystemSystemdBaseFactory.config + \
        TestInitSystemSystemdRoIfupdownDbusbrokerDbus.config


class TestInitSystemSystemdRoFullFactory(
    InitSystemSystemdBaseFactory,
    TestInitSystemSystemdRoFull,
):
    config = InitSystemSystemdBaseFactory.config + \
        TestInitSystemSystemdRoFull.config


# Helper class for overlayfs-based tests
class InitSystemSystemdBaseOverlayfs():
    config = \
        """
        # BR2_INIT_SYSTEMD_VAR_FACTORY is not set
        BR2_INIT_SYSTEMD_VAR_OVERLAYFS=y
        BR2_ROOTFS_OVERLAY="{}"
        BR2_LINUX_KERNEL=y
        BR2_LINUX_KERNEL_CUSTOM_VERSION=y
        BR2_LINUX_KERNEL_CUSTOM_VERSION_VALUE="5.10.202"
        BR2_LINUX_KERNEL_DEFCONFIG="vexpress"
        BR2_LINUX_KERNEL_CONFIG_FRAGMENT_FILES="{}"
        BR2_LINUX_KERNEL_DTS_SUPPORT=y
        BR2_LINUX_KERNEL_INTREE_DTS_NAME="vexpress-v2p-ca9"
        """.format(infra.filepath("tests/init/systemd-factory"),
                   infra.filepath("conf/overlayfs-kernel-fragment.config"))

    def test_run(self):
        super().test_run()

        # This one must be executed on the target, to check that
        # the tmpfiles pre-populate works as expected
        out, exit_code = self.emulator.run("cat /var/foo/bar")
        self.assertEqual(exit_code, 0)
        self.assertEqual(out[0], "foobar")

        # /var/foo/bar is from the pre-populated /var, so it should
        # not be present in the upper of the overlay
        _, exit_code = self.emulator.run("test -e /run/buildroot/mounts/var/upper/foo/bar")
        self.assertNotEqual(exit_code, 0)

        # We can write in /var/foo/bar
        _, exit_code = self.emulator.run("echo barfoo >/var/foo/bar")
        self.assertEqual(exit_code, 0)
        # ... and it contains the new content
        out, exit_code = self.emulator.run("cat /var/foo/bar")
        self.assertEqual(exit_code, 0)
        self.assertEqual(out[0], "barfoo")
        # ... and it to appears in the upper
        _, exit_code = self.emulator.run("test -e /run/buildroot/mounts/var/upper/foo/bar")
        self.assertEqual(exit_code, 0)
        # ... with the new content
        out, exit_code = self.emulator.run("cat /run/buildroot/mounts/var/upper/foo/bar")
        self.assertEqual(exit_code, 0)
        self.assertEqual(out[0], "barfoo")
        # ... while the lower still has the oldcontent
        out, exit_code = self.emulator.run("cat /run/buildroot/mounts/var/lower/foo/bar")
        self.assertEqual(exit_code, 0)
        self.assertEqual(out[0], "foobar")


class TestInitSystemSystemdRoNetworkdOverlayfs(
    InitSystemSystemdBaseOverlayfs,
    TestInitSystemSystemdRoNetworkd,
):
    config = InitSystemSystemdBaseOverlayfs.config + \
        TestInitSystemSystemdRoNetworkd.config


class TestInitSystemSystemdRoIfupdownOverlayfs(
    InitSystemSystemdBaseOverlayfs,
    TestInitSystemSystemdRoIfupdown,
):
    config = InitSystemSystemdBaseOverlayfs.config + \
        TestInitSystemSystemdRoIfupdown.config


class TestInitSystemSystemdRoIfupdownDbusbrokerOverlayfs(
    InitSystemSystemdBaseOverlayfs,
    TestInitSystemSystemdRoIfupdownDbusbroker,
):
    config = InitSystemSystemdBaseOverlayfs.config + \
        TestInitSystemSystemdRoIfupdownDbusbroker.config


class TestInitSystemSystemdRoIfupdownDbusbrokerDbusOverlayfs(
    InitSystemSystemdBaseOverlayfs,
    TestInitSystemSystemdRoIfupdownDbusbrokerDbus,
):
    config = InitSystemSystemdBaseOverlayfs.config + \
        TestInitSystemSystemdRoIfupdownDbusbrokerDbus.config


class TestInitSystemSystemdRoFullOverlayfs(
    InitSystemSystemdBaseOverlayfs,
    TestInitSystemSystemdRoFull,
):
    config = InitSystemSystemdBaseOverlayfs.config + \
        TestInitSystemSystemdRoFull.config


class InitSystemSystemdBaseOverlayfsVarBacking(InitSystemBase):
    @classmethod
    def gen_config(cls, overlaydir: str) -> str:
        return re.sub(
            r'^\s*BR2_ROOTFS_OVERLAY="(.*)"$',
            'BR2_ROOTFS_OVERLAY="\\1 {}"'.format(infra.filepath(overlaydir)),
            TestInitSystemSystemdRoFullOverlayfs.config,
            flags=re.MULTILINE,
        )

    def check_var_mounted(self):
        self.assertRunOk("grep '^other-var-backing-store /run/buildroot/mounts/var tmpfs' /proc/mounts")


class TestInitSystemSystemdRoFullOverlayfsVarBackingMountUnit(
    TestInitSystemSystemdRoFullOverlayfs,
    InitSystemSystemdBaseOverlayfsVarBacking,
):
    config = InitSystemSystemdBaseOverlayfsVarBacking.gen_config(
        'tests/init/systemd-overlay-mount-unit',
    )

    def test_run(self):
        super().test_run()
        self.check_var_mounted()


class TestInitSystemSystemdRoFullOverlayfsVarBackingFstab(
    TestInitSystemSystemdRoFullOverlayfs,
    InitSystemSystemdBaseOverlayfsVarBacking,
):
    config = InitSystemSystemdBaseOverlayfsVarBacking.gen_config(
        'tests/init/systemd-overlay-fstab',
    )

    def test_run(self):
        super().test_run()
        self.check_var_mounted()