From ef45d169b07a9482886a643f52ca9fe48b76f16b Mon Sep 17 00:00:00 2001 From: "Brian C. Lane" Date: Fri, 2 Nov 2018 11:47:31 -0700 Subject: [PATCH] Add some tests for creator.py This is complicated by the fact that much of this module requires mount. So for now just test the things that don't need mount. (cherry picked from commit 134a333d92da7d3cd80627152d922e9e7101cf47) --- Dockerfile.test | 2 + tests/pylorax/test_creator.py | 121 ++++++++++++++++++++++++++++++++++ 2 files changed, 123 insertions(+) create mode 100644 tests/pylorax/test_creator.py diff --git a/Dockerfile.test b/Dockerfile.test index 82487d4c..c8c67472 100644 --- a/Dockerfile.test +++ b/Dockerfile.test @@ -22,6 +22,8 @@ RUN dnf -y install \ sudo \ tito \ rsync \ + e2fsprogs \ + squashfs-tools \ which RUN useradd weldr VOLUME /lorax diff --git a/tests/pylorax/test_creator.py b/tests/pylorax/test_creator.py new file mode 100644 index 00000000..dc3e373d --- /dev/null +++ b/tests/pylorax/test_creator.py @@ -0,0 +1,121 @@ +# +# Copyright (C) 2018 Red Hat, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# +import os +import tempfile +import unittest +import xml.etree.ElementTree as ET + +from pylorax import find_templates +from pylorax.base import DataHolder +from pylorax.creator import FakeDNF, create_pxe_config, make_appliance, make_squashfs, squashfs_args +from pylorax.executils import runcmd +from pylorax.imgutils import mksparse +from pylorax.sysutils import joinpaths + +class CreatorTest(unittest.TestCase): + def fakednf_test(self): + """Test FakeDNF class""" + fake_dbo = FakeDNF(conf=DataHolder(installroot="/a/fake/install/root/")) + self.assertEqual(fake_dbo.conf.installroot, "/a/fake/install/root/") + + def squashfs_args_test(self): + """Test squashfs_args results""" + test_arches = {"x86_64": ("xz", ["-Xbcj", "x86"]), + "ppc64": ("xz", ["-Xbcj", "powerpc"]), + "ppc64le": ("xz", ["-Xbcj", "powerpc"]), + "s390x": ("xz", []), + "ia64": ("xz", []), + "aarch64": ("xz", []) + } + + for arch in test_arches: + opts = DataHolder(compression=None, arch=arch) + self.assertEqual(squashfs_args(opts), test_arches[arch], (opts, squashfs_args(opts))) + + opts = DataHolder(compression="lzma", arch="x86_64") + self.assertEqual(squashfs_args(opts), ("lzma", []), (opts, squashfs_args(opts))) + + def make_appliance_test(self): + """Test creating the appliance description XML file""" + lorax_templates = find_templates("./share/") + appliance_template = joinpaths(lorax_templates, "appliance/libvirt.tmpl") + self.assertTrue(os.path.exists(appliance_template)) + + # A fake disk image + with tempfile.NamedTemporaryFile(prefix="lorax.test.disk.") as disk_img: + open(disk_img.name, "wb").write(b"THIS IS A FAKE DISK IMAGE FILE") + with tempfile.NamedTemporaryFile(prefix="lorax.test.appliance.") as output_xml: + make_appliance(disk_img.name, "test-appliance", appliance_template, output_xml.name, + ["eth0", "eth1"], ram=4096, vcpus=8, arch="x86_64", + title="Lorax Test", project="Fedora", releasever="30") + + print(open(output_xml.name).read()) + # Parse the XML and check for known fields + tree = ET.parse(output_xml.name) + image = tree.getroot() + self.assertEqual(image.find("name").text, "test-appliance") + boot = image.find("./domain/boot") + self.assertEqual(boot.get("type"), "hvm") + self.assertEqual(boot.find("./guest/arch").text, "x86_64") + self.assertEqual(boot.find("./os/loader").get("dev"), "hd") + self.assertTrue(boot.find("drive").get("disk").startswith("lorax.test.disk.")) + self.assertEqual(boot.find("drive").get("target"), "hda") + devices = image.find("./domain/devices") + self.assertEqual(devices.find("vcpu").text, "8") + self.assertEqual(devices.find("memory").text, "4096") + self.assertTrue(len(devices.findall("interface")), 2) + storage = image.find("storage") + self.assertTrue(storage.find("disk").get("file").startswith("lorax.test.disk.")) + self.assertEqual(storage.find("./disk/checksum").get("type"), "sha256") + self.assertEqual(storage.find("./disk/checksum").text, "90611458b33009998f73e25ccc3766b31a8b548cc6c2d84f78ae0e84d64e10a5") + + def pxe_config_test(self): + """Test creation of a PXE config file""" + with tempfile.TemporaryDirectory(prefix="lorax.test.") as work_dir: + live_image_name = "live-rootfs.squashfs.img" + add_pxe_args = ["ostree=/mnt/sysimage/"] + lorax_templates = find_templates("./share/") + template = joinpaths(lorax_templates, "pxe-live/pxe-config.tmpl") + + # Make a fake kernel and initrd + open(joinpaths(work_dir, "vmlinuz-4.18.13-200.fc28.x86_64"), "w").write("I AM A FAKE KERNEL") + open(joinpaths(work_dir, "initramfs-4.18.13-200.fc28.x86_64.img"), "w").write("I AM A FAKE INITRD") + + # Create the PXE_CONFIG in work_dir + create_pxe_config(template, work_dir, live_image_name, add_pxe_args) + print(open(joinpaths(work_dir, "PXE_CONFIG")).read()) + pxe_config = open(joinpaths(work_dir, "PXE_CONFIG")).read() + self.assertTrue("vmlinuz-4.18.13-200.fc28.x86_64" in pxe_config) + self.assertTrue("initramfs-4.18.13-200.fc28.x86_64.img" in pxe_config) + self.assertTrue("/live-rootfs.squashfs.img ostree=/mnt/sysimage/" in pxe_config) + + def make_squashfs_test(self): + """Test making a squashfs image""" + with tempfile.TemporaryDirectory(prefix="lorax.test.") as work_dir: + with tempfile.NamedTemporaryFile(prefix="lorax.test.disk.") as disk_img: + # Make a small ext4 disk image + mksparse(disk_img.name, 42 * 1024**2) + runcmd(["mkfs.ext4", "-L", "Anaconda", "-b", "4096", "-m", "0", disk_img.name]) + opts = DataHolder(compression="xz", arch="x86_64") + make_squashfs(opts, disk_img.name, work_dir) + + # Make sure it made an install.img + self.assertTrue(os.path.exists(joinpaths(work_dir, "images/install.img"))) + + # Make sure it looks like a squashfs filesystem + squashfs_sig = open(joinpaths(work_dir, "images/install.img"), "rb").read(4) + self.assertTrue(squashfs_sig in [b"hsqs", b"sqsh"])