bootstrap_test.go

package baremetal

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"libvirt.org/go/libvirtxml"
)

func TestNewDomain(t *testing.T) {
	dom := newDomain("test-bootstrap")

	assert.Equal(t, "test-bootstrap", dom.Name)
	assert.Equal(t, "kvm", dom.Type)
	assert.Equal(t, "hvm", dom.OS.Type.Type)
	assert.Empty(t, dom.OS.Type.Arch, "arch should not be set by newDomain")
	assert.Empty(t, dom.OS.Type.Machine, "machine should not be set by newDomain")
	assert.Equal(t, uint(6), dom.Memory.Value)
	assert.Equal(t, "GiB", dom.Memory.Unit)
	assert.Equal(t, uint(4), dom.VCPU.Value)
	assert.Equal(t, "host-passthrough", dom.CPU.Mode)
	assert.NotEmpty(t, dom.Devices.RNGs, "RNG device should be configured")
	assert.NotEmpty(t, dom.Devices.Graphics, "graphics should be configured")
	assert.NotEmpty(t, dom.Devices.Consoles, "console should be configured")
	assert.NotEmpty(t, dom.Devices.Serials, "serial device should be configured")
	assert.NotNil(t, dom.Devices.Serials[0].Log, "serial device should have a log file configured")
	assert.Equal(t, "/var/log/libvirt/qemu/test-bootstrap-serial0.log", dom.Devices.Serials[0].Log.File)
	assert.Equal(t, "on", dom.Devices.Serials[0].Log.Append)
	assert.Nil(t, dom.Devices.Serials[0].Target, "serial target should not be set by newDomain")
}

func TestConfigureDomainArch(t *testing.T) {
	tests := []struct {
		name           string
		arch           string
		expectMachine  string
		expectFirmware string
		expectGraphics bool
	}{
		{
			name:           "x86_64 sets q35 and efi",
			arch:           "x86_64",
			expectMachine:  "q35",
			expectFirmware: "efi",
			expectGraphics: true,
		},
		{
			name:           "aarch64 sets efi and removes graphics",
			arch:           "aarch64",
			expectMachine:  "",
			expectFirmware: "efi",
			expectGraphics: false,
		},
		{
			name:           "s390x removes graphics",
			arch:           "s390x",
			expectMachine:  "",
			expectFirmware: "",
			expectGraphics: false,
		},
		{
			name:           "ppc64le removes graphics",
			arch:           "ppc64le",
			expectMachine:  "",
			expectFirmware: "",
			expectGraphics: false,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			dom := newDomain("test-bootstrap")
			configureDomainArch(&dom, tc.arch)

			assert.Equal(t, tc.arch, dom.OS.Type.Arch)
			assert.Equal(t, tc.expectMachine, dom.OS.Type.Machine)
			assert.Equal(t, tc.expectFirmware, dom.OS.Firmware)

			if tc.expectGraphics {
				assert.NotNil(t, dom.Devices.Graphics, "graphics should be present for %s", tc.arch)
			} else {
				assert.Nil(t, dom.Devices.Graphics, "graphics should be removed for %s", tc.arch)
			}

			assert.NotEmpty(t, dom.Devices.Serials, "serial device should be present for %s", tc.arch)
		})
	}
}

func TestConfigureDomainArchPreservesOtherFields(t *testing.T) {
	dom := newDomain("test-bootstrap")

	dom.Devices.Interfaces = []libvirtxml.DomainInterface{
		{
			Model: &libvirtxml.DomainInterfaceModel{Type: "virtio"},
		},
	}

	configureDomainArch(&dom, "x86_64")

	assert.Len(t, dom.Devices.Interfaces, 1, "interfaces should not be modified")
	assert.Equal(t, "hvm", dom.OS.Type.Type, "OS type should remain hvm")
	assert.Equal(t, "kvm", dom.Type, "domain type should remain kvm")
}

func TestBuildBootstrapKargs(t *testing.T) {
	tests := []struct {
		name           string
		arch           string
		fips           bool
		expectContains []string
		expectMissing  []string
	}{
		{
			name:           "x86_64 default",
			arch:           "x86_64",
			fips:           false,
			expectContains: []string{"console=ttyS0,115200n8"},
			expectMissing:  []string{"fips=1"},
		},
		{
			name:           "x86_64 with FIPS",
			arch:           "x86_64",
			fips:           true,
			expectContains: []string{"console=ttyS0,115200n8", "fips=1"},
		},
		{
			name:           "aarch64 default",
			arch:           "aarch64",
			fips:           false,
			expectContains: []string{"console=ttyAMA0,115200"},
			expectMissing:  []string{"fips=1"},
		},
		{
			name:           "s390x default",
			arch:           "s390x",
			fips:           false,
			expectContains: []string{"console=ttysclp0"},
			expectMissing:  []string{"fips=1"},
		},
		{
			name:           "ppc64le default",
			arch:           "ppc64le",
			fips:           false,
			expectContains: []string{"console=hvc0"},
			expectMissing:  []string{"fips=1"},
		},
		{
			name:          "unknown arch returns nil",
			arch:          "riscv64",
			fips:          false,
			expectMissing: []string{"console="},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := buildBootstrapKargs(tc.arch, tc.fips)

			if len(tc.expectContains) == 0 && len(tc.expectMissing) > 0 {
				assert.Nil(t, result, "kargs should be nil for unknown arch without FIPS")
				return
			}

			assert.NotNil(t, result, "kargs should not be nil")
			kargs := string(result)
			assert.True(t, kargs[len(kargs)-1] == '\n', "kargs should end with newline")

			for _, s := range tc.expectContains {
				assert.Contains(t, kargs, s)
			}
			for _, s := range tc.expectMissing {
				assert.NotContains(t, kargs, s)
			}
		})
	}
}