Add unit tests to SMBIOS support feature

Author: yasminvalim

mantle/cmd/kola/options.go

@@ -67,7 +67,6 @@ func init() {
 	sv(&kola.Sharding, "sharding", "", "Provide e.g. 'hash:m/n' where m and n are integers, 1 <= m <= n.  Only tests hashing to m will be run.")
 	bv(&kola.Options.SSHOnTestFailure, "ssh-on-test-failure", false, "SSH into a machine when tests fail")
 	bv(&kola.QEMUOptions.NoIgnition, "no-ignition", false, "Run without Ignition; provision SSH via systemd SMBIOS credentials (requires -p qemu and --qemu-image)")
-	sv(&kola.QEMUOptions.SSHUser, "ssh-user", "", "SSH user when using --no-ignition (default: root)")
 	sv(&kola.Options.Stream, "stream", "", "CoreOS stream ID (e.g. for Fedora CoreOS: stable, testing, next)")
 	sv(&kola.Options.CosaWorkdir, "workdir", "", "coreos-assembler working directory")
 	sv(&kola.Options.CosaBuildId, "build", "", "coreos-assembler build ID (or e.g. -1, -2, for previous builds)")

mantle/kola/harness.go

@@ -1821,10 +1821,9 @@ func runTest(h *harness.H, t *register.Test, pltfrm string, flight platform.Flig
 		WarningsAction:     conf.FailWarnings,
 		EarlyRelease:       h.Release,
 		TestExecTimeout:    h.TimeoutContext(),
-		NoIgnition:         QEMUOptions.NoIgnition,
-		SSHUser:            QEMUOptions.SSHUser,
+		NoIgnition: QEMUOptions.NoIgnition,
 	}
-	if QEMUOptions.NoIgnition && rconf.SSHUser == "" {
+	if QEMUOptions.NoIgnition {
 		rconf.SSHUser = "root"
 	}
 	if t.HasFlag(register.AllowConfigWarnings) {

mantle/kola/tests/coretest/core.go

@@ -111,7 +111,6 @@ func init() {
 		},
 		// FIXME run on RHCOS once it has https://github.com/coreos/ignition-dracut/pull/93
 		Distros: []string{"fcos"},
-		Tags:    []string{kola.BootcBaseTag},
 	})
 	register.RegisterTest(&register.Test{
 		Name:        "rhcos.services-disabled",

mantle/kola/tests/ostree/unlock.go

@@ -31,15 +31,15 @@ func init() {
 		Name:        "ostree.unlock",
 		Description: "Verify installing an rpm does not persist when using `ostree admin unlock`.",
 		FailFast:    true,
-		Tags:        []string{"ostree", kola.NeedsInternetTag, kola.BootcBaseTag}, // need network to pull RPM
+		Tags:        []string{"ostree", kola.NeedsInternetTag}, // need network to pull RPM
 	})
 	register.RegisterTest(&register.Test{
 		Run:         ostreeHotfixTest,
 		ClusterSize: 1,
 		Name:        "ostree.hotfix",
 		Description: "Verify that the deployment can be put into hotfix mode where RPMs installed with persist across reboots.",
 		FailFast:    true,
-		Tags:        []string{"ostree", kola.NeedsInternetTag, kola.BootcBaseTag}, // need network to pull RPM
+		Tags:        []string{"ostree", kola.NeedsInternetTag}, // need network to pull RPM
 	})
 }
 

mantle/kola/tests/rpmostree/deployments.go

@@ -33,7 +33,7 @@ func init() {
 		Name:        "rpmostree.upgrade-rollback",
 		Description: "Verify an upgrade and rollback with a simulated update works.",
 		FailFast:    true,
-		Tags:        []string{"rpm-ostree", "upgrade", kola.BootcBaseTag},
+		Tags:        []string{"rpm-ostree", "upgrade"},
 	})
 	register.RegisterTest(&register.Test{
 		Run:         rpmOstreeInstallUninstall,

mantle/platform/machine/qemu/cluster.go

@@ -46,39 +46,48 @@ func (qc *Cluster) NewMachine(userdata *conf.UserData) (platform.Machine, error)
 	return qc.NewMachineWithOptions(userdata, platform.MachineOptions{})
 }
 
-func (qc *Cluster) NewMachineWithOptions(userdata *conf.UserData, options platform.MachineOptions) (platform.Machine, error) {
-	if options.InstanceType != "" {
-		return nil, errors.New("platform qemu does not support changing instance types")
+// ensureBuilderDefaults applies flight-level QEMU settings to a builder.
+func (qc *Cluster) ensureBuilderDefaults(builder *platform.QemuBuilder) (*platform.QemuBuilder, error) {
+	if builder == nil {
+		builder = platform.NewQemuBuilder()
 	}
-	id := uuid.New()
-
-	dir := filepath.Join(qc.RuntimeConf().OutputDir, id)
-	if err := os.Mkdir(dir, 0777); err != nil {
-		return nil, err
+	if qc.flight.opts.Arch != "" {
+		if err := builder.SetArchitecture(qc.flight.opts.Arch); err != nil {
+			return nil, err
+		}
+	}
+	if qc.flight.opts.Firmware != "" {
+		builder.Firmware = qc.flight.opts.Firmware
 	}
+	builder.Swtpm = qc.flight.opts.Swtpm
+	return builder, nil
+}
 
+// createMachine prepares a machine and configures Ignition or SMBIOS SSH credentials
+// on the builder. When --no-ignition is set, userdata may be nil.
+func (qc *Cluster) createMachine(builder *platform.QemuBuilder, userdata *conf.UserData, options platform.MachineOptions, dir, id string) (*machine, *conf.Conf, error) {
 	rconf := qc.RuntimeConf()
 	noIgnition := rconf.NoIgnition
 
 	var config *conf.Conf
 	if noIgnition {
 		if qc.flight.opts.SecureExecution {
-			return nil, errors.New("secure execution requires Ignition; not supported with --no-ignition")
+			return nil, nil, errors.New("secure execution requires Ignition; not supported with --no-ignition")
 		}
 		if len(append(qc.flight.opts.BindRO, options.BindMountHostRO...)) > 0 {
-			return nil, errors.New("bind mounts require Ignition; not supported with --no-ignition")
+			return nil, nil, errors.New("bind mounts require Ignition; not supported with --no-ignition")
 		}
 	} else {
 		var err error
 		config, err = qc.RenderUserDataIfNeeded(userdata)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
 
 	journal, err := platform.NewJournal(dir)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	qm := &machine{
@@ -88,14 +97,9 @@ func (qc *Cluster) NewMachineWithOptions(userdata *conf.UserData, options platfo
 		consolePath: filepath.Join(dir, "console.txt"),
 	}
 
-	builder := platform.NewQemuBuilder()
-	if options.DisablePDeathSig {
-		builder.Pdeathsig = false
-	}
-
 	if qc.flight.opts.SecureExecution {
 		if err := builder.SetSecureExecution(qc.flight.opts.SecureExecutionIgnitionPubKey, qc.flight.opts.SecureExecutionHostKey, config); err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
 
@@ -110,53 +114,77 @@ func (qc *Cluster) NewMachineWithOptions(userdata *conf.UserData, options platfo
 	for _, mountpair := range append(qc.flight.opts.BindRO, options.BindMountHostRO...) {
 		src, dest, err := platform.ParseBindOpt(mountpair)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		readonly := true
 		builder.MountHost(src, dest, readonly)
-		config.MountHost(dest, readonly)
+		if config != nil {
+			config.MountHost(dest, readonly)
+		}
 	}
 
 	if noIgnition {
 		keys, err := qc.Keys()
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		smbios, err := platform.SystemdSMBIOSSSHCredential(rconf.SSHUser, keys)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		builder.Smbios = append(builder.Smbios, smbios)
 	} else {
 		builder.SetConfig(config)
 	}
-	defer builder.Close()
-	builder.UUID = qm.id
-	if qc.flight.opts.Arch != "" {
-		if err := builder.SetArchitecture(qc.flight.opts.Arch); err != nil {
-			return nil, err
-		}
+
+	return qm, config, nil
+}
+
+func (qc *Cluster) NewMachineWithOptions(userdata *conf.UserData, options platform.MachineOptions) (platform.Machine, error) {
+	if options.InstanceType != "" {
+		return nil, errors.New("platform qemu does not support changing instance types")
 	}
-	if qc.flight.opts.Firmware != "" {
-		builder.Firmware = qc.flight.opts.Firmware
+	id := uuid.New()
+
+	dir := filepath.Join(qc.RuntimeConf().OutputDir, id)
+	if err := os.Mkdir(dir, 0777); err != nil {
+		return nil, err
 	}
-	builder.Swtpm = qc.flight.opts.Swtpm
-	builder.Hostname = fmt.Sprintf("qemu%d", qc.BaseCluster.AllocateMachineSerial())
-	builder.ConsoleFile = qm.consolePath
+
+	qemuBuilder := platform.NewQemuBuilder()
+	if options.DisablePDeathSig {
+		qemuBuilder.Pdeathsig = false
+	}
+
+	var err error
+	qemuBuilder, err = qc.ensureBuilderDefaults(qemuBuilder)
+	if err != nil {
+		return nil, err
+	}
+
+	qm, _, err := qc.createMachine(qemuBuilder, userdata, options, dir, id)
+	if err != nil {
+		return nil, err
+	}
+
+	defer qemuBuilder.Close()
+	qemuBuilder.UUID = qm.id
+	qemuBuilder.ConsoleFile = qm.consolePath
+	qemuBuilder.NumaNodes = options.NumaNodes
+	qemuBuilder.Hostname = fmt.Sprintf("qemu%d", qc.BaseCluster.AllocateMachineSerial())
 
 	if qc.flight.opts.Memory != "" {
 		memory, err := strconv.ParseInt(qc.flight.opts.Memory, 10, 32)
 		if err != nil {
 			return nil, errors.Wrapf(err, "parsing memory option")
 		}
-		builder.MemoryMiB = int(memory)
+		qemuBuilder.MemoryMiB = int(memory)
 	} else if options.MinMemory != 0 {
-		builder.MemoryMiB = options.MinMemory
+		qemuBuilder.MemoryMiB = options.MinMemory
 	} else if qc.flight.opts.SecureExecution {
-		builder.MemoryMiB = 4096 // SE needs at least 4GB
+		qemuBuilder.MemoryMiB = 4096 // SE needs at least 4GB
 	}
 
-	builder.NumaNodes = options.NumaNodes
 	var primaryDisk platform.Disk
 	if options.PrimaryDisk != "" {
 		var diskp *platform.Disk
@@ -167,7 +195,7 @@ func (qc *Cluster) NewMachineWithOptions(userdata *conf.UserData, options platfo
 	}
 
 	if qc.flight.opts.Cex || options.Cex {
-		if err := builder.AddCexDevice(); err != nil {
+		if err := qemuBuilder.AddCexDevice(); err != nil {
 			return nil, err
 		}
 	}
@@ -194,38 +222,38 @@ func (qc *Cluster) NewMachineWithOptions(userdata *conf.UserData, options platfo
 		primaryDisk.BackingFile = options.OverrideBackingFile
 	}
 
-	if err = builder.AddBootDisk(&primaryDisk); err != nil {
+	if err = qemuBuilder.AddBootDisk(&primaryDisk); err != nil {
 		return nil, err
 	}
-	if err = builder.AddDisksFromSpecs(options.AdditionalDisks); err != nil {
+	if err = qemuBuilder.AddDisksFromSpecs(options.AdditionalDisks); err != nil {
 		return nil, err
 	}
 
 	if len(options.HostForwardPorts) > 0 {
-		builder.EnableUsermodeNetworking(options.HostForwardPorts, "")
+		qemuBuilder.EnableUsermodeNetworking(options.HostForwardPorts, "")
 	} else {
 		h := []platform.HostForwardPort{
 			{Service: "ssh", HostPort: 0, GuestPort: 22},
 		}
-		builder.EnableUsermodeNetworking(h, "")
+		qemuBuilder.EnableUsermodeNetworking(h, "")
 	}
 	if options.AdditionalNics > 0 {
-		builder.AddAdditionalNics(options.AdditionalNics)
+		qemuBuilder.AddAdditionalNics(options.AdditionalNics)
 	}
 	if options.AppendKernelArgs != "" {
-		builder.AppendKernelArgs = options.AppendKernelArgs
+		qemuBuilder.AppendKernelArgs = options.AppendKernelArgs
 	}
 	if options.AppendFirstbootKernelArgs != "" {
-		builder.AppendFirstbootKernelArgs = options.AppendFirstbootKernelArgs
+		qemuBuilder.AppendFirstbootKernelArgs = options.AppendFirstbootKernelArgs
 	}
 	if !qc.RuntimeConf().InternetAccess {
-		builder.RestrictNetworking = true
+		qemuBuilder.RestrictNetworking = true
 	}
 	if options.Firmware != "" {
-		builder.Firmware = options.Firmware
+		qemuBuilder.Firmware = options.Firmware
 	}
 
-	inst, err := builder.Exec()
+	inst, err := qemuBuilder.Exec()
 	if err != nil {
 		return nil, err
 	}

mantle/platform/machine/qemu/flight.go

@@ -60,8 +60,6 @@ type Options struct {
 
 	// NoIgnition skips Ignition; SSH keys are provisioned via systemd SMBIOS credentials.
 	NoIgnition bool
-	// SSHUser is the SSH login user when NoIgnition is set (default root).
-	SSHUser string
 
 	*platform.Options
 }

mantle/platform/platform.go

@@ -288,7 +288,7 @@ type RuntimeConfig struct {
 	// NoIgnition skips Ignition when launching QEMU VMs; SSH keys are
 	// provisioned via systemd SMBIOS credentials instead.
 	NoIgnition bool
-	// SSHUser overrides the default SSH user (core) when set.
+	// SSHUser overrides the default SSH user (core) when set (e.g. root with --no-ignition).
 	SSHUser string
 }
 

mantle/platform/smbios_test.go

@@ -0,0 +1,66 @@
+// Copyright 2026 Red Hat
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package platform
+
+import (
+	"crypto/ed25519"
+	"crypto/rand"
+	"encoding/base64"
+	"strings"
+	"testing"
+
+	"golang.org/x/crypto/ssh"
+	"golang.org/x/crypto/ssh/agent"
+)
+
+func TestSystemdSMBIOSSSHCredential(t *testing.T) {
+	_, priv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	signer, err := ssh.NewSignerFromKey(priv)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pub := signer.PublicKey()
+	keys := []*agent.Key{{Format: pub.Type(), Blob: pub.Marshal()}}
+
+	val, err := SystemdSMBIOSSSHCredential("root", keys)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.HasPrefix(val, "type=11,value=io.systemd.credential.binary:tmpfiles.extra=") {
+		t.Fatalf("unexpected smbios value prefix: %q", val)
+	}
+
+	payloadB64 := strings.TrimPrefix(val, "type=11,value=io.systemd.credential.binary:tmpfiles.extra=")
+	tmpfiles, err := base64.StdEncoding.DecodeString(payloadB64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(tmpfiles), "/root/.ssh") {
+		t.Fatalf("tmpfiles missing root ssh dir: %q", tmpfiles)
+	}
+	if !strings.Contains(string(tmpfiles), "authorized_keys") {
+		t.Fatalf("tmpfiles missing authorized_keys: %q", tmpfiles)
+	}
+}
+
+func TestSystemdSMBIOSSSHCredentialNoKeys(t *testing.T) {
+	_, err := SystemdSMBIOSSSHCredential("root", nil)
+	if err == nil {
+		t.Fatal("expected error for empty keys")
+	}
+}