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 134a333d92)

Dockerfile.test

@@ -22,6 +22,8 @@ RUN dnf -y install \
   sudo \
   tito \
   rsync \
+  e2fsprogs \
+  squashfs-tools \
   which
 RUN useradd weldr
 VOLUME /lorax

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 <http://www.gnu.org/licenses/>.
+#
+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"])