You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/agent/internal/hypervisor/backend_test.go

296 lines
9.5 KiB
Go

package hypervisor
import (
"context"
"errors"
"fmt"
"strings"
"sync"
"testing"
"time"
)
const testUUID = "00000000-0000-4000-8000-000000000001"
func testDomainXML(uuid string) []byte {
return []byte(fmt.Sprintf(`<domain type="kvm"><name>test-vm</name><uuid>%s</uuid><os><type>hvm</type></os><devices/></domain>`, uuid))
}
func TestCanonicalUUID(t *testing.T) {
tests := []struct {
name string
in string
want string
err bool
}{
{name: "lowercase", in: testUUID, want: testUUID},
{name: "uppercase is canonicalized", in: strings.ToUpper(testUUID), want: testUUID},
{name: "trimmed", in: " " + testUUID + "\n", want: testUUID},
{name: "bad length", in: "00000000-0000-4000-8000-00000000000", err: true},
{name: "bad separator", in: "000000000000-4000-8000-000000000001", err: true},
{name: "bad hex", in: "00000000-0000-4000-8000-00000000000g", err: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := CanonicalUUID(tt.in)
if tt.err {
if !errors.Is(err, ErrInvalidUUID) {
t.Fatalf("CanonicalUUID() error = %v, want ErrInvalidUUID", err)
}
return
}
if err != nil || got != tt.want {
t.Fatalf("CanonicalUUID() = %q, err=%v, want %q", got, err, tt.want)
}
})
}
}
func TestCheckEFIQ35NoSecureBoot(t *testing.T) {
base := DefaultCapabilitySnapshot()
if err := CheckEFIQ35NoSecureBoot(base); err != nil {
t.Fatalf("default capability policy rejected: %v", err)
}
for name, mutate := range map[string]func(*CapabilitySnapshot){
"efi": func(value *CapabilitySnapshot) { value.UEFI = false },
"q35": func(value *CapabilitySnapshot) { value.Q35 = false },
"secure boot": func(value *CapabilitySnapshot) { value.SecureBootDisabled = false },
} {
t.Run(name, func(t *testing.T) {
value := base
mutate(&value)
if err := CheckEFIQ35NoSecureBoot(value); !errors.Is(err, ErrCapabilityPolicy) {
t.Fatalf("CheckEFIQ35NoSecureBoot() error = %v, want ErrCapabilityPolicy", err)
}
})
}
}
func TestFakeBackendSelectsFreshNonSecureLoader(t *testing.T) {
backend := NewFakeBackend(DefaultCapabilitySnapshot())
path, err := backend.PreferredNonSecureLoaderPath(context.Background())
if err != nil {
t.Fatalf("PreferredNonSecureLoaderPath() error = %v", err)
}
if path != fakeLoaderPath {
t.Fatalf("loader path = %q, want %q", path, fakeLoaderPath)
}
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, err := backend.PreferredNonSecureLoaderPath(ctx); !errors.Is(err, context.Canceled) {
t.Fatalf("canceled loader selection error = %v, want context.Canceled", err)
}
}
func TestFakeBackendDefineAndReadback(t *testing.T) {
backend := NewFakeBackend(DefaultCapabilitySnapshot())
defined, err := backend.DefineDomain(context.Background(), DefineRequest{
UUID: testUUID,
XML: testDomainXML(testUUID),
})
if err != nil {
t.Fatalf("DefineDomain() error = %v", err)
}
if defined.UUID != testUUID || defined.Revision != 1 || len(defined.XML) == 0 {
t.Fatalf("unexpected definition: %+v", defined)
}
if err := domainPolicyFromDefinition(defined.XML); err != nil {
t.Fatal(err)
}
readback, err := ReadbackDomain(context.Background(), backend, strings.ToUpper(testUUID))
if err != nil {
t.Fatalf("ReadbackDomain() error = %v", err)
}
if readback.UUID != testUUID || string(readback.XML) != string(defined.XML) {
t.Fatalf("readback changed definition: got=%+v defined=%+v", readback, defined)
}
// Returned bytes are copies. Mutating them must not alter the backend's
// read-back state.
defined.XML[0] = 'X'
again, err := backend.ReadDomainXML(context.Background(), testUUID)
if err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(string(again), "<domain") {
t.Fatalf("backend XML was aliased through returned bytes: %q", again[:minInt(len(again), 20)])
}
}
func TestFakeBackendRejectsUUIDMismatchAndConflictingRedefinition(t *testing.T) {
backend := NewFakeBackend(DefaultCapabilitySnapshot())
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
UUID: testUUID,
XML: testDomainXML("00000000-0000-4000-8000-000000000002"),
}); !errors.Is(err, ErrUUIDMismatch) {
t.Fatalf("UUID mismatch error = %v, want ErrUUIDMismatch", err)
}
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
UUID: testUUID,
XML: testDomainXML(testUUID),
}); err != nil {
t.Fatal(err)
}
changed := strings.Replace(string(testDomainXML(testUUID)), "test-vm", "other-vm", 1)
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
UUID: testUUID,
XML: []byte(changed),
}); !errors.Is(err, ErrDomainConflict) {
t.Fatalf("conflicting redefine error = %v, want ErrDomainConflict", err)
}
}
func TestFakeBackendDoesNotDefineWhenPlatformPolicyIsUnavailable(t *testing.T) {
caps := DefaultCapabilitySnapshot()
caps.SecureBootDisabled = false
backend := NewFakeBackend(caps)
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
UUID: testUUID,
XML: testDomainXML(testUUID),
}); !errors.Is(err, ErrCapabilityPolicy) {
t.Fatalf("DefineDomain() error = %v, want ErrCapabilityPolicy", err)
}
if _, err := backend.ReadDomainXML(context.Background(), testUUID); !errors.Is(err, ErrDomainNotFound) {
t.Fatalf("failed define left a domain behind: %v", err)
}
}
func TestFakeBackendConcurrentIdempotentDefine(t *testing.T) {
backend := NewFakeBackend(DefaultCapabilitySnapshot())
const workers = 32
results := make(chan Definition, workers)
errs := make(chan error, workers)
var wait sync.WaitGroup
wait.Add(workers)
for i := 0; i < workers; i++ {
go func() {
defer wait.Done()
definition, err := backend.DefineDomain(context.Background(), DefineRequest{
UUID: testUUID,
XML: testDomainXML(testUUID),
})
if err != nil {
errs <- err
return
}
results <- definition
}()
}
wait.Wait()
close(results)
close(errs)
for err := range errs {
t.Fatalf("concurrent define failed: %v", err)
}
for definition := range results {
if definition.UUID != testUUID || definition.Revision != 1 {
t.Fatalf("concurrent define returned inconsistent definition: %+v", definition)
}
}
readback, err := ReadbackDomain(context.Background(), backend, testUUID)
if err != nil {
t.Fatal(err)
}
if readback.UUID != testUUID {
t.Fatalf("readback UUID = %q, want %q", readback.UUID, testUUID)
}
}
func TestFakeBackendContextCancellationAndMissingDomain(t *testing.T) {
backend := NewFakeBackend(DefaultCapabilitySnapshot())
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, err := backend.Probe(ctx); !errors.Is(err, context.Canceled) {
t.Fatalf("Probe() error = %v, want context.Canceled", err)
}
if _, err := backend.ReadDomainXML(context.Background(), testUUID); !errors.Is(err, ErrDomainNotFound) {
t.Fatalf("ReadDomainXML() error = %v, want ErrDomainNotFound", err)
}
}
func TestReadbackDomainRejectsBackendPolicyDrift(t *testing.T) {
backend := &staticXMLBackend{xml: []byte(fmt.Sprintf(`<domain><uuid>%s</uuid><os><type arch="x86_64" machine="q35">hvm</type><firmware><feature name="secure-boot" enabled="yes"/></firmware></os></domain>`, testUUID))}
if _, err := ReadbackDomain(context.Background(), backend, testUUID); !errors.Is(err, ErrReadbackMismatch) {
t.Fatalf("ReadbackDomain() error = %v, want ErrReadbackMismatch", err)
}
}
type staticXMLBackend struct {
xml []byte
}
func (s *staticXMLBackend) Probe(context.Context) (ProbeResult, error) {
return ProbeResult{Capabilities: DefaultCapabilitySnapshot()}, nil
}
func (s *staticXMLBackend) Capabilities(context.Context) (CapabilitySnapshot, error) {
return DefaultCapabilitySnapshot(), nil
}
func (s *staticXMLBackend) DefineDomain(context.Context, DefineRequest) (Definition, error) {
return Definition{}, errors.New("not implemented")
}
func (s *staticXMLBackend) ReadDomainXML(context.Context, string) ([]byte, error) {
return append([]byte(nil), s.xml...), nil
}
func (s *staticXMLBackend) PowerDomain(context.Context, string, PowerAction) (PowerResult, error) {
return PowerResult{}, errors.New("not implemented")
}
func (s *staticXMLBackend) ReadDomainPowerState(context.Context, string) (DomainPowerState, error) {
return StateShutoff, nil
}
func (s *staticXMLBackend) InspectDomainForDeletion(ctx context.Context, uuid string) (DomainDeletionObservation, error) {
data, err := s.ReadDomainXML(ctx, uuid)
if err != nil {
return DomainDeletionObservation{}, err
}
canonical, err := CanonicalUUID(uuid)
if err != nil {
return DomainDeletionObservation{}, err
}
observed, err := domainUUID(data)
if err != nil || observed != canonical {
return DomainDeletionObservation{}, ErrReadbackMismatch
}
return DomainDeletionObservation{
UUID: canonical,
Present: true,
State: StateShutoff,
XMLHash: hashDomainXML(data),
ObservedAt: time.Now().UTC(),
}, nil
}
func (s *staticXMLBackend) DeleteDomain(context.Context, string) (DomainDeleteResult, error) {
return DomainDeleteResult{}, errors.New("not implemented")
}
func domainPolicyFromDefinition(data []byte) error {
// This helper intentionally uses the same exported policy validator that a
// real binding must call after libvirt XMLDesc read-back.
if err := validateDomainXML(data); err != nil {
return err
}
return nil
}
func validateDomainXML(data []byte) error {
// Keep the test package independent from unexported implementation details.
if !strings.Contains(string(data), `name="secure-boot" enabled="no"`) {
return fmt.Errorf("normalized definition does not disable Secure Boot: %s", data)
}
return nil
}
func minInt(a, b int) int {
if a < b {
return a
}
return b
}